# -*- coding: utf-8 -*-
from gi.repository import Gio
from gi.repository import GObject


class AnchorHints:
    """Positioning hints for aligning a window relative to a rectangle.

These hints determine how the window should be positioned in the case that
the window would fall off-screen if placed in its ideal position.

For example, %GDK_ANCHOR_FLIP_X will replace %GDK_GRAVITY_NORTH_WEST with
%GDK_GRAVITY_NORTH_EAST and vice versa if the window extends beyond the left
or right edges of the monitor.

If %GDK_ANCHOR_SLIDE_X is set, the window can be shifted horizontally to fit
on-screen. If %GDK_ANCHOR_RESIZE_X is set, the window can be shrunken
horizontally to fit.

In general, when multiple flags are set, flipping should take precedence over
sliding, which should take precedence over resizing."""
    FLIP_X = 1
    FLIP_Y = 2
    SLIDE_X = 4
    SLIDE_Y = 8
    RESIZE_X = 16
    RESIZE_Y = 32
    FLIP = 3
    SLIDE = 12
    RESIZE = 48


class AxisFlags:
    """Flags describing the current capabilities of a device/tool."""
    X = 2
    Y = 4
    PRESSURE = 8
    XTILT = 16
    YTILT = 32
    WHEEL = 64
    DISTANCE = 128
    ROTATION = 256
    SLIDER = 512


class AxisUse:
    """An enumeration describing the way in which a device
axis (valuator) maps onto the predefined valuator
types that GTK+ understands.

Note that the X and Y axes are not really needed; pointer devices
report their location via the x/y members of events regardless. Whether
X and Y are present as axes depends on the GDK backend."""
    IGNORE = 0
    X = 1
    Y = 2
    PRESSURE = 3
    XTILT = 4
    YTILT = 5
    WHEEL = 6
    DISTANCE = 7
    ROTATION = 8
    SLIDER = 9
    LAST = 10
BUTTON_MIDDLE = r"""2"""
BUTTON_PRIMARY = r"""1"""
BUTTON_SECONDARY = r"""3"""


class ByteOrder:
    """A set of values describing the possible byte-orders
for storing pixel values in memory."""
    LSB_FIRST = 0
    MSB_FIRST = 1
CURRENT_TIME = r"""0"""


class CrossingMode:
    """Specifies the crossing mode for #GdkEventCrossing."""
    NORMAL = 0
    GRAB = 1
    UNGRAB = 2
    GTK_GRAB = 3
    GTK_UNGRAB = 4
    STATE_CHANGED = 5
    TOUCH_BEGIN = 6
    TOUCH_END = 7
    DEVICE_SWITCH = 8


class CursorType:
    """Predefined cursors.

Note that these IDs are directly taken from the X cursor font, and many
of these cursors are either not useful, or are not available on other platforms.

The recommended way to create cursors is to use gdk_cursor_new_from_name()."""
    X_CURSOR = 0
    ARROW = 2
    BASED_ARROW_DOWN = 4
    BASED_ARROW_UP = 6
    BOAT = 8
    BOGOSITY = 10
    BOTTOM_LEFT_CORNER = 12
    BOTTOM_RIGHT_CORNER = 14
    BOTTOM_SIDE = 16
    BOTTOM_TEE = 18
    BOX_SPIRAL = 20
    CENTER_PTR = 22
    CIRCLE = 24
    CLOCK = 26
    COFFEE_MUG = 28
    CROSS = 30
    CROSS_REVERSE = 32
    CROSSHAIR = 34
    DIAMOND_CROSS = 36
    DOT = 38
    DOTBOX = 40
    DOUBLE_ARROW = 42
    DRAFT_LARGE = 44
    DRAFT_SMALL = 46
    DRAPED_BOX = 48
    EXCHANGE = 50
    FLEUR = 52
    GOBBLER = 54
    GUMBY = 56
    HAND1 = 58
    HAND2 = 60
    HEART = 62
    ICON = 64
    IRON_CROSS = 66
    LEFT_PTR = 68
    LEFT_SIDE = 70
    LEFT_TEE = 72
    LEFTBUTTON = 74
    LL_ANGLE = 76
    LR_ANGLE = 78
    MAN = 80
    MIDDLEBUTTON = 82
    MOUSE = 84
    PENCIL = 86
    PIRATE = 88
    PLUS = 90
    QUESTION_ARROW = 92
    RIGHT_PTR = 94
    RIGHT_SIDE = 96
    RIGHT_TEE = 98
    RIGHTBUTTON = 100
    RTL_LOGO = 102
    SAILBOAT = 104
    SB_DOWN_ARROW = 106
    SB_H_DOUBLE_ARROW = 108
    SB_LEFT_ARROW = 110
    SB_RIGHT_ARROW = 112
    SB_UP_ARROW = 114
    SB_V_DOUBLE_ARROW = 116
    SHUTTLE = 118
    SIZING = 120
    SPIDER = 122
    SPRAYCAN = 124
    STAR = 126
    TARGET = 128
    TCROSS = 130
    TOP_LEFT_ARROW = 132
    TOP_LEFT_CORNER = 134
    TOP_RIGHT_CORNER = 136
    TOP_SIDE = 138
    TOP_TEE = 140
    TREK = 142
    UL_ANGLE = 144
    UMBRELLA = 146
    UR_ANGLE = 148
    WATCH = 150
    XTERM = 152
    LAST_CURSOR = 153
    BLANK_CURSOR = -2
    CURSOR_IS_PIXMAP = -1


class DevicePadFeature:
    """A pad feature."""
    BUTTON = 0
    RING = 1
    STRIP = 2


class DeviceToolType:
    """Indicates the specific type of tool being used being a tablet. Such as an
airbrush, pencil, etc."""
    UNKNOWN = 0
    PEN = 1
    ERASER = 2
    BRUSH = 3
    PENCIL = 4
    AIRBRUSH = 5
    MOUSE = 6
    LENS = 7


class DeviceType:
    """Indicates the device type. See [above][GdkDeviceManager.description]
for more information about the meaning of these device types."""
    MASTER = 0
    SLAVE = 1
    FLOATING = 2


class DragAction:
    """Used in #GdkDragContext to indicate what the destination
should do with the dropped data."""
    DEFAULT = 1
    COPY = 2
    MOVE = 4
    LINK = 8
    PRIVATE = 16
    ASK = 32


class DragCancelReason:
    """Used in #GdkDragContext to the reason of a cancelled DND operation."""
    NO_TARGET = 0
    USER_CANCELLED = 1
    ERROR = 2


class DragProtocol:
    """Used in #GdkDragContext to indicate the protocol according to
which DND is done."""
    NONE = 0
    MOTIF = 1
    XDND = 2
    ROOTWIN = 3
    WIN32_DROPFILES = 4
    OLE2 = 5
    LOCAL = 6
    WAYLAND = 7
EVENT_PROPAGATE = r"""false"""
EVENT_STOP = r"""true"""


class EventMask:
    """A set of bit-flags to indicate which events a window is to receive.
Most of these masks map onto one or more of the #GdkEventType event types
above.

See the [input handling overview][chap-input-handling] for details of
[event masks][event-masks] and [event propagation][event-propagation].

%GDK_POINTER_MOTION_HINT_MASK is deprecated. It is a special mask
to reduce the number of %GDK_MOTION_NOTIFY events received. When using
%GDK_POINTER_MOTION_HINT_MASK, fewer %GDK_MOTION_NOTIFY events will
be sent, some of which are marked as a hint (the is_hint member is
%TRUE). To receive more motion events after a motion hint event,
the application needs to asks for more, by calling
gdk_event_request_motions().

Since GTK 3.8, motion events are already compressed by default, independent
of this mechanism. This compression can be disabled with
gdk_window_set_event_compression(). See the documentation of that function
for details.

If %GDK_TOUCH_MASK is enabled, the window will receive touch events
from touch-enabled devices. Those will come as sequences of #GdkEventTouch
with type %GDK_TOUCH_UPDATE, enclosed by two events with
type %GDK_TOUCH_BEGIN and %GDK_TOUCH_END (or %GDK_TOUCH_CANCEL).
gdk_event_get_event_sequence() returns the event sequence for these
events, so different sequences may be distinguished."""
    EXPOSURE_MASK = 2
    POINTER_MOTION_MASK = 4
    POINTER_MOTION_HINT_MASK = 8
    BUTTON_MOTION_MASK = 16
    BUTTON1_MOTION_MASK = 32
    BUTTON2_MOTION_MASK = 64
    BUTTON3_MOTION_MASK = 128
    BUTTON_PRESS_MASK = 256
    BUTTON_RELEASE_MASK = 512
    KEY_PRESS_MASK = 1024
    KEY_RELEASE_MASK = 2048
    ENTER_NOTIFY_MASK = 4096
    LEAVE_NOTIFY_MASK = 8192
    FOCUS_CHANGE_MASK = 16384
    STRUCTURE_MASK = 32768
    PROPERTY_CHANGE_MASK = 65536
    VISIBILITY_NOTIFY_MASK = 131072
    PROXIMITY_IN_MASK = 262144
    PROXIMITY_OUT_MASK = 524288
    SUBSTRUCTURE_MASK = 1048576
    SCROLL_MASK = 2097152
    TOUCH_MASK = 4194304
    SMOOTH_SCROLL_MASK = 8388608
    TOUCHPAD_GESTURE_MASK = 16777216
    TABLET_PAD_MASK = 33554432
    ALL_EVENTS_MASK = 67108862


class EventType:
    """Specifies the type of the event.

Do not confuse these events with the signals that GTK+ widgets emit.
Although many of these events result in corresponding signals being emitted,
the events are often transformed or filtered along the way.

In some language bindings, the values %GDK_2BUTTON_PRESS and
%GDK_3BUTTON_PRESS would translate into something syntactically
invalid (eg `Gdk.EventType.2ButtonPress`, where a
symbol is not allowed to start with a number). In that case, the
aliases %GDK_DOUBLE_BUTTON_PRESS and %GDK_TRIPLE_BUTTON_PRESS can
be used instead."""
    NOTHING = -1
    DELETE = 0
    DESTROY = 1
    EXPOSE = 2
    MOTION_NOTIFY = 3
    BUTTON_PRESS = 4
    _2BUTTON_PRESS = 5
    DOUBLE_BUTTON_PRESS = 5
    _3BUTTON_PRESS = 6
    TRIPLE_BUTTON_PRESS = 6
    BUTTON_RELEASE = 7
    KEY_PRESS = 8
    KEY_RELEASE = 9
    ENTER_NOTIFY = 10
    LEAVE_NOTIFY = 11
    FOCUS_CHANGE = 12
    CONFIGURE = 13
    MAP = 14
    UNMAP = 15
    PROPERTY_NOTIFY = 16
    SELECTION_CLEAR = 17
    SELECTION_REQUEST = 18
    SELECTION_NOTIFY = 19
    PROXIMITY_IN = 20
    PROXIMITY_OUT = 21
    DRAG_ENTER = 22
    DRAG_LEAVE = 23
    DRAG_MOTION = 24
    DRAG_STATUS = 25
    DROP_START = 26
    DROP_FINISHED = 27
    CLIENT_EVENT = 28
    VISIBILITY_NOTIFY = 29
    SCROLL = 31
    WINDOW_STATE = 32
    SETTING = 33
    OWNER_CHANGE = 34
    GRAB_BROKEN = 35
    DAMAGE = 36
    TOUCH_BEGIN = 37
    TOUCH_UPDATE = 38
    TOUCH_END = 39
    TOUCH_CANCEL = 40
    TOUCHPAD_SWIPE = 41
    TOUCHPAD_PINCH = 42
    PAD_BUTTON_PRESS = 43
    PAD_BUTTON_RELEASE = 44
    PAD_RING = 45
    PAD_STRIP = 46
    PAD_GROUP_MODE = 47
    EVENT_LAST = 48


class FilterReturn:
    """Specifies the result of applying a #GdkFilterFunc to a native event."""
    CONTINUE = 0
    TRANSLATE = 1
    REMOVE = 2


class FrameClockPhase:
    """#GdkFrameClockPhase is used to represent the different paint clock
phases that can be requested. The elements of the enumeration
correspond to the signals of #GdkFrameClock."""
    NONE = 0
    FLUSH_EVENTS = 1
    BEFORE_PAINT = 2
    UPDATE = 4
    LAYOUT = 8
    PAINT = 16
    RESUME_EVENTS = 32
    AFTER_PAINT = 64


class FullscreenMode:
    """Indicates which monitor (in a multi-head setup) a window should span over
when in fullscreen mode."""
    CURRENT_MONITOR = 0
    ALL_MONITORS = 1


class GLError:
    """Error enumeration for #GdkGLContext."""
    NOT_AVAILABLE = 0
    UNSUPPORTED_FORMAT = 1
    UNSUPPORTED_PROFILE = 2


class GrabOwnership:
    """Defines how device grabs interact with other devices."""
    NONE = 0
    WINDOW = 1
    APPLICATION = 2


class GrabStatus:
    """Returned by gdk_device_grab(), gdk_pointer_grab() and gdk_keyboard_grab() to
indicate success or the reason for the failure of the grab attempt."""
    SUCCESS = 0
    ALREADY_GRABBED = 1
    INVALID_TIME = 2
    NOT_VIEWABLE = 3
    FROZEN = 4
    FAILED = 5


class Gravity:
    """Defines the reference point of a window and the meaning of coordinates
passed to gtk_window_move(). See gtk_window_move() and the "implementation
notes" section of the
[Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
specification for more details."""
    NORTH_WEST = 1
    NORTH = 2
    NORTH_EAST = 3
    WEST = 4
    CENTER = 5
    EAST = 6
    SOUTH_WEST = 7
    SOUTH = 8
    SOUTH_EAST = 9
    STATIC = 10


class InputMode:
    """An enumeration that describes the mode of an input device."""
    DISABLED = 0
    SCREEN = 1
    WINDOW = 2


class InputSource:
    """An enumeration describing the type of an input device in general terms."""
    MOUSE = 0
    PEN = 1
    ERASER = 2
    CURSOR = 3
    KEYBOARD = 4
    TOUCHSCREEN = 5
    TOUCHPAD = 6
    TRACKPOINT = 7
    TABLET_PAD = 8
KEY_0 = r"""48"""
KEY_1 = r"""49"""
KEY_2 = r"""50"""
KEY_3 = r"""51"""
KEY_3270_AltCursor = r"""64784"""
KEY_3270_Attn = r"""64782"""
KEY_3270_BackTab = r"""64773"""
KEY_3270_ChangeScreen = r"""64793"""
KEY_3270_Copy = r"""64789"""
KEY_3270_CursorBlink = r"""64783"""
KEY_3270_CursorSelect = r"""64796"""
KEY_3270_DeleteWord = r"""64794"""
KEY_3270_Duplicate = r"""64769"""
KEY_3270_Enter = r"""64798"""
KEY_3270_EraseEOF = r"""64774"""
KEY_3270_EraseInput = r"""64775"""
KEY_3270_ExSelect = r"""64795"""
KEY_3270_FieldMark = r"""64770"""
KEY_3270_Ident = r"""64787"""
KEY_3270_Jump = r"""64786"""
KEY_3270_KeyClick = r"""64785"""
KEY_3270_Left2 = r"""64772"""
KEY_3270_PA1 = r"""64778"""
KEY_3270_PA2 = r"""64779"""
KEY_3270_PA3 = r"""64780"""
KEY_3270_Play = r"""64790"""
KEY_3270_PrintScreen = r"""64797"""
KEY_3270_Quit = r"""64777"""
KEY_3270_Record = r"""64792"""
KEY_3270_Reset = r"""64776"""
KEY_3270_Right2 = r"""64771"""
KEY_3270_Rule = r"""64788"""
KEY_3270_Setup = r"""64791"""
KEY_3270_Test = r"""64781"""
KEY_4 = r"""52"""
KEY_5 = r"""53"""
KEY_6 = r"""54"""
KEY_7 = r"""55"""
KEY_8 = r"""56"""
KEY_9 = r"""57"""
KEY_A = r"""65"""
KEY_AE = r"""198"""
KEY_Aacute = r"""193"""
KEY_Abelowdot = r"""16785056"""
KEY_Abreve = r"""451"""
KEY_Abreveacute = r"""16785070"""
KEY_Abrevebelowdot = r"""16785078"""
KEY_Abrevegrave = r"""16785072"""
KEY_Abrevehook = r"""16785074"""
KEY_Abrevetilde = r"""16785076"""
KEY_AccessX_Enable = r"""65136"""
KEY_AccessX_Feedback_Enable = r"""65137"""
KEY_Acircumflex = r"""194"""
KEY_Acircumflexacute = r"""16785060"""
KEY_Acircumflexbelowdot = r"""16785068"""
KEY_Acircumflexgrave = r"""16785062"""
KEY_Acircumflexhook = r"""16785064"""
KEY_Acircumflextilde = r"""16785066"""
KEY_AddFavorite = r"""269025081"""
KEY_Adiaeresis = r"""196"""
KEY_Agrave = r"""192"""
KEY_Ahook = r"""16785058"""
KEY_Alt_L = r"""65513"""
KEY_Alt_R = r"""65514"""
KEY_Amacron = r"""960"""
KEY_Aogonek = r"""417"""
KEY_ApplicationLeft = r"""269025104"""
KEY_ApplicationRight = r"""269025105"""
KEY_Arabic_0 = r"""16778848"""
KEY_Arabic_1 = r"""16778849"""
KEY_Arabic_2 = r"""16778850"""
KEY_Arabic_3 = r"""16778851"""
KEY_Arabic_4 = r"""16778852"""
KEY_Arabic_5 = r"""16778853"""
KEY_Arabic_6 = r"""16778854"""
KEY_Arabic_7 = r"""16778855"""
KEY_Arabic_8 = r"""16778856"""
KEY_Arabic_9 = r"""16778857"""
KEY_Arabic_ain = r"""1497"""
KEY_Arabic_alef = r"""1479"""
KEY_Arabic_alefmaksura = r"""1513"""
KEY_Arabic_beh = r"""1480"""
KEY_Arabic_comma = r"""1452"""
KEY_Arabic_dad = r"""1494"""
KEY_Arabic_dal = r"""1487"""
KEY_Arabic_damma = r"""1519"""
KEY_Arabic_dammatan = r"""1516"""
KEY_Arabic_ddal = r"""16778888"""
KEY_Arabic_farsi_yeh = r"""16778956"""
KEY_Arabic_fatha = r"""1518"""
KEY_Arabic_fathatan = r"""1515"""
KEY_Arabic_feh = r"""1505"""
KEY_Arabic_fullstop = r"""16778964"""
KEY_Arabic_gaf = r"""16778927"""
KEY_Arabic_ghain = r"""1498"""
KEY_Arabic_ha = r"""1511"""
KEY_Arabic_hah = r"""1485"""
KEY_Arabic_hamza = r"""1473"""
KEY_Arabic_hamza_above = r"""16778836"""
KEY_Arabic_hamza_below = r"""16778837"""
KEY_Arabic_hamzaonalef = r"""1475"""
KEY_Arabic_hamzaonwaw = r"""1476"""
KEY_Arabic_hamzaonyeh = r"""1478"""
KEY_Arabic_hamzaunderalef = r"""1477"""
KEY_Arabic_heh = r"""1511"""
KEY_Arabic_heh_doachashmee = r"""16778942"""
KEY_Arabic_heh_goal = r"""16778945"""
KEY_Arabic_jeem = r"""1484"""
KEY_Arabic_jeh = r"""16778904"""
KEY_Arabic_kaf = r"""1507"""
KEY_Arabic_kasra = r"""1520"""
KEY_Arabic_kasratan = r"""1517"""
KEY_Arabic_keheh = r"""16778921"""
KEY_Arabic_khah = r"""1486"""
KEY_Arabic_lam = r"""1508"""
KEY_Arabic_madda_above = r"""16778835"""
KEY_Arabic_maddaonalef = r"""1474"""
KEY_Arabic_meem = r"""1509"""
KEY_Arabic_noon = r"""1510"""
KEY_Arabic_noon_ghunna = r"""16778938"""
KEY_Arabic_peh = r"""16778878"""
KEY_Arabic_percent = r"""16778858"""
KEY_Arabic_qaf = r"""1506"""
KEY_Arabic_question_mark = r"""1471"""
KEY_Arabic_ra = r"""1489"""
KEY_Arabic_rreh = r"""16778897"""
KEY_Arabic_sad = r"""1493"""
KEY_Arabic_seen = r"""1491"""
KEY_Arabic_semicolon = r"""1467"""
KEY_Arabic_shadda = r"""1521"""
KEY_Arabic_sheen = r"""1492"""
KEY_Arabic_sukun = r"""1522"""
KEY_Arabic_superscript_alef = r"""16778864"""
KEY_Arabic_switch = r"""65406"""
KEY_Arabic_tah = r"""1495"""
KEY_Arabic_tatweel = r"""1504"""
KEY_Arabic_tcheh = r"""16778886"""
KEY_Arabic_teh = r"""1482"""
KEY_Arabic_tehmarbuta = r"""1481"""
KEY_Arabic_thal = r"""1488"""
KEY_Arabic_theh = r"""1483"""
KEY_Arabic_tteh = r"""16778873"""
KEY_Arabic_veh = r"""16778916"""
KEY_Arabic_waw = r"""1512"""
KEY_Arabic_yeh = r"""1514"""
KEY_Arabic_yeh_baree = r"""16778962"""
KEY_Arabic_zah = r"""1496"""
KEY_Arabic_zain = r"""1490"""
KEY_Aring = r"""197"""
KEY_Armenian_AT = r"""16778552"""
KEY_Armenian_AYB = r"""16778545"""
KEY_Armenian_BEN = r"""16778546"""
KEY_Armenian_CHA = r"""16778569"""
KEY_Armenian_DA = r"""16778548"""
KEY_Armenian_DZA = r"""16778561"""
KEY_Armenian_E = r"""16778551"""
KEY_Armenian_FE = r"""16778582"""
KEY_Armenian_GHAT = r"""16778562"""
KEY_Armenian_GIM = r"""16778547"""
KEY_Armenian_HI = r"""16778565"""
KEY_Armenian_HO = r"""16778560"""
KEY_Armenian_INI = r"""16778555"""
KEY_Armenian_JE = r"""16778571"""
KEY_Armenian_KE = r"""16778580"""
KEY_Armenian_KEN = r"""16778559"""
KEY_Armenian_KHE = r"""16778557"""
KEY_Armenian_LYUN = r"""16778556"""
KEY_Armenian_MEN = r"""16778564"""
KEY_Armenian_NU = r"""16778566"""
KEY_Armenian_O = r"""16778581"""
KEY_Armenian_PE = r"""16778570"""
KEY_Armenian_PYUR = r"""16778579"""
KEY_Armenian_RA = r"""16778572"""
KEY_Armenian_RE = r"""16778576"""
KEY_Armenian_SE = r"""16778573"""
KEY_Armenian_SHA = r"""16778567"""
KEY_Armenian_TCHE = r"""16778563"""
KEY_Armenian_TO = r"""16778553"""
KEY_Armenian_TSA = r"""16778558"""
KEY_Armenian_TSO = r"""16778577"""
KEY_Armenian_TYUN = r"""16778575"""
KEY_Armenian_VEV = r"""16778574"""
KEY_Armenian_VO = r"""16778568"""
KEY_Armenian_VYUN = r"""16778578"""
KEY_Armenian_YECH = r"""16778549"""
KEY_Armenian_ZA = r"""16778550"""
KEY_Armenian_ZHE = r"""16778554"""
KEY_Armenian_accent = r"""16778587"""
KEY_Armenian_amanak = r"""16778588"""
KEY_Armenian_apostrophe = r"""16778586"""
KEY_Armenian_at = r"""16778600"""
KEY_Armenian_ayb = r"""16778593"""
KEY_Armenian_ben = r"""16778594"""
KEY_Armenian_but = r"""16778589"""
KEY_Armenian_cha = r"""16778617"""
KEY_Armenian_da = r"""16778596"""
KEY_Armenian_dza = r"""16778609"""
KEY_Armenian_e = r"""16778599"""
KEY_Armenian_exclam = r"""16778588"""
KEY_Armenian_fe = r"""16778630"""
KEY_Armenian_full_stop = r"""16778633"""
KEY_Armenian_ghat = r"""16778610"""
KEY_Armenian_gim = r"""16778595"""
KEY_Armenian_hi = r"""16778613"""
KEY_Armenian_ho = r"""16778608"""
KEY_Armenian_hyphen = r"""16778634"""
KEY_Armenian_ini = r"""16778603"""
KEY_Armenian_je = r"""16778619"""
KEY_Armenian_ke = r"""16778628"""
KEY_Armenian_ken = r"""16778607"""
KEY_Armenian_khe = r"""16778605"""
KEY_Armenian_ligature_ew = r"""16778631"""
KEY_Armenian_lyun = r"""16778604"""
KEY_Armenian_men = r"""16778612"""
KEY_Armenian_nu = r"""16778614"""
KEY_Armenian_o = r"""16778629"""
KEY_Armenian_paruyk = r"""16778590"""
KEY_Armenian_pe = r"""16778618"""
KEY_Armenian_pyur = r"""16778627"""
KEY_Armenian_question = r"""16778590"""
KEY_Armenian_ra = r"""16778620"""
KEY_Armenian_re = r"""16778624"""
KEY_Armenian_se = r"""16778621"""
KEY_Armenian_separation_mark = r"""16778589"""
KEY_Armenian_sha = r"""16778615"""
KEY_Armenian_shesht = r"""16778587"""
KEY_Armenian_tche = r"""16778611"""
KEY_Armenian_to = r"""16778601"""
KEY_Armenian_tsa = r"""16778606"""
KEY_Armenian_tso = r"""16778625"""
KEY_Armenian_tyun = r"""16778623"""
KEY_Armenian_verjaket = r"""16778633"""
KEY_Armenian_vev = r"""16778622"""
KEY_Armenian_vo = r"""16778616"""
KEY_Armenian_vyun = r"""16778626"""
KEY_Armenian_yech = r"""16778597"""
KEY_Armenian_yentamna = r"""16778634"""
KEY_Armenian_za = r"""16778598"""
KEY_Armenian_zhe = r"""16778602"""
KEY_Atilde = r"""195"""
KEY_AudibleBell_Enable = r"""65146"""
KEY_AudioCycleTrack = r"""269025179"""
KEY_AudioForward = r"""269025175"""
KEY_AudioLowerVolume = r"""269025041"""
KEY_AudioMedia = r"""269025074"""
KEY_AudioMicMute = r"""269025202"""
KEY_AudioMute = r"""269025042"""
KEY_AudioNext = r"""269025047"""
KEY_AudioPause = r"""269025073"""
KEY_AudioPlay = r"""269025044"""
KEY_AudioPrev = r"""269025046"""
KEY_AudioRaiseVolume = r"""269025043"""
KEY_AudioRandomPlay = r"""269025177"""
KEY_AudioRecord = r"""269025052"""
KEY_AudioRepeat = r"""269025176"""
KEY_AudioRewind = r"""269025086"""
KEY_AudioStop = r"""269025045"""
KEY_Away = r"""269025165"""
KEY_B = r"""66"""
KEY_Babovedot = r"""16784898"""
KEY_Back = r"""269025062"""
KEY_BackForward = r"""269025087"""
KEY_BackSpace = r"""65288"""
KEY_Battery = r"""269025171"""
KEY_Begin = r"""65368"""
KEY_Blue = r"""269025190"""
KEY_Bluetooth = r"""269025172"""
KEY_Book = r"""269025106"""
KEY_BounceKeys_Enable = r"""65140"""
KEY_Break = r"""65387"""
KEY_BrightnessAdjust = r"""269025083"""
KEY_Byelorussian_SHORTU = r"""1726"""
KEY_Byelorussian_shortu = r"""1710"""
KEY_C = r"""67"""
KEY_CD = r"""269025107"""
KEY_CH = r"""65186"""
KEY_C_H = r"""65189"""
KEY_C_h = r"""65188"""
KEY_Cabovedot = r"""709"""
KEY_Cacute = r"""454"""
KEY_Calculator = r"""269025053"""
KEY_Calendar = r"""269025056"""
KEY_Cancel = r"""65385"""
KEY_Caps_Lock = r"""65509"""
KEY_Ccaron = r"""456"""
KEY_Ccedilla = r"""199"""
KEY_Ccircumflex = r"""710"""
KEY_Ch = r"""65185"""
KEY_Clear = r"""65291"""
KEY_ClearGrab = r"""269024801"""
KEY_Close = r"""269025110"""
KEY_Codeinput = r"""65335"""
KEY_ColonSign = r"""16785569"""
KEY_Community = r"""269025085"""
KEY_ContrastAdjust = r"""269025058"""
KEY_Control_L = r"""65507"""
KEY_Control_R = r"""65508"""
KEY_Copy = r"""269025111"""
KEY_CruzeiroSign = r"""16785570"""
KEY_Cut = r"""269025112"""
KEY_CycleAngle = r"""269025180"""
KEY_Cyrillic_A = r"""1761"""
KEY_Cyrillic_BE = r"""1762"""
KEY_Cyrillic_CHE = r"""1790"""
KEY_Cyrillic_CHE_descender = r"""16778422"""
KEY_Cyrillic_CHE_vertstroke = r"""16778424"""
KEY_Cyrillic_DE = r"""1764"""
KEY_Cyrillic_DZHE = r"""1727"""
KEY_Cyrillic_E = r"""1788"""
KEY_Cyrillic_EF = r"""1766"""
KEY_Cyrillic_EL = r"""1772"""
KEY_Cyrillic_EM = r"""1773"""
KEY_Cyrillic_EN = r"""1774"""
KEY_Cyrillic_EN_descender = r"""16778402"""
KEY_Cyrillic_ER = r"""1778"""
KEY_Cyrillic_ES = r"""1779"""
KEY_Cyrillic_GHE = r"""1767"""
KEY_Cyrillic_GHE_bar = r"""16778386"""
KEY_Cyrillic_HA = r"""1768"""
KEY_Cyrillic_HARDSIGN = r"""1791"""
KEY_Cyrillic_HA_descender = r"""16778418"""
KEY_Cyrillic_I = r"""1769"""
KEY_Cyrillic_IE = r"""1765"""
KEY_Cyrillic_IO = r"""1715"""
KEY_Cyrillic_I_macron = r"""16778466"""
KEY_Cyrillic_JE = r"""1720"""
KEY_Cyrillic_KA = r"""1771"""
KEY_Cyrillic_KA_descender = r"""16778394"""
KEY_Cyrillic_KA_vertstroke = r"""16778396"""
KEY_Cyrillic_LJE = r"""1721"""
KEY_Cyrillic_NJE = r"""1722"""
KEY_Cyrillic_O = r"""1775"""
KEY_Cyrillic_O_bar = r"""16778472"""
KEY_Cyrillic_PE = r"""1776"""
KEY_Cyrillic_SCHWA = r"""16778456"""
KEY_Cyrillic_SHA = r"""1787"""
KEY_Cyrillic_SHCHA = r"""1789"""
KEY_Cyrillic_SHHA = r"""16778426"""
KEY_Cyrillic_SHORTI = r"""1770"""
KEY_Cyrillic_SOFTSIGN = r"""1784"""
KEY_Cyrillic_TE = r"""1780"""
KEY_Cyrillic_TSE = r"""1763"""
KEY_Cyrillic_U = r"""1781"""
KEY_Cyrillic_U_macron = r"""16778478"""
KEY_Cyrillic_U_straight = r"""16778414"""
KEY_Cyrillic_U_straight_bar = r"""16778416"""
KEY_Cyrillic_VE = r"""1783"""
KEY_Cyrillic_YA = r"""1777"""
KEY_Cyrillic_YERU = r"""1785"""
KEY_Cyrillic_YU = r"""1760"""
KEY_Cyrillic_ZE = r"""1786"""
KEY_Cyrillic_ZHE = r"""1782"""
KEY_Cyrillic_ZHE_descender = r"""16778390"""
KEY_Cyrillic_a = r"""1729"""
KEY_Cyrillic_be = r"""1730"""
KEY_Cyrillic_che = r"""1758"""
KEY_Cyrillic_che_descender = r"""16778423"""
KEY_Cyrillic_che_vertstroke = r"""16778425"""
KEY_Cyrillic_de = r"""1732"""
KEY_Cyrillic_dzhe = r"""1711"""
KEY_Cyrillic_e = r"""1756"""
KEY_Cyrillic_ef = r"""1734"""
KEY_Cyrillic_el = r"""1740"""
KEY_Cyrillic_em = r"""1741"""
KEY_Cyrillic_en = r"""1742"""
KEY_Cyrillic_en_descender = r"""16778403"""
KEY_Cyrillic_er = r"""1746"""
KEY_Cyrillic_es = r"""1747"""
KEY_Cyrillic_ghe = r"""1735"""
KEY_Cyrillic_ghe_bar = r"""16778387"""
KEY_Cyrillic_ha = r"""1736"""
KEY_Cyrillic_ha_descender = r"""16778419"""
KEY_Cyrillic_hardsign = r"""1759"""
KEY_Cyrillic_i = r"""1737"""
KEY_Cyrillic_i_macron = r"""16778467"""
KEY_Cyrillic_ie = r"""1733"""
KEY_Cyrillic_io = r"""1699"""
KEY_Cyrillic_je = r"""1704"""
KEY_Cyrillic_ka = r"""1739"""
KEY_Cyrillic_ka_descender = r"""16778395"""
KEY_Cyrillic_ka_vertstroke = r"""16778397"""
KEY_Cyrillic_lje = r"""1705"""
KEY_Cyrillic_nje = r"""1706"""
KEY_Cyrillic_o = r"""1743"""
KEY_Cyrillic_o_bar = r"""16778473"""
KEY_Cyrillic_pe = r"""1744"""
KEY_Cyrillic_schwa = r"""16778457"""
KEY_Cyrillic_sha = r"""1755"""
KEY_Cyrillic_shcha = r"""1757"""
KEY_Cyrillic_shha = r"""16778427"""
KEY_Cyrillic_shorti = r"""1738"""
KEY_Cyrillic_softsign = r"""1752"""
KEY_Cyrillic_te = r"""1748"""
KEY_Cyrillic_tse = r"""1731"""
KEY_Cyrillic_u = r"""1749"""
KEY_Cyrillic_u_macron = r"""16778479"""
KEY_Cyrillic_u_straight = r"""16778415"""
KEY_Cyrillic_u_straight_bar = r"""16778417"""
KEY_Cyrillic_ve = r"""1751"""
KEY_Cyrillic_ya = r"""1745"""
KEY_Cyrillic_yeru = r"""1753"""
KEY_Cyrillic_yu = r"""1728"""
KEY_Cyrillic_ze = r"""1754"""
KEY_Cyrillic_zhe = r"""1750"""
KEY_Cyrillic_zhe_descender = r"""16778391"""
KEY_D = r"""68"""
KEY_DOS = r"""269025114"""
KEY_Dabovedot = r"""16784906"""
KEY_Dcaron = r"""463"""
KEY_Delete = r"""65535"""
KEY_Display = r"""269025113"""
KEY_Documents = r"""269025115"""
KEY_DongSign = r"""16785579"""
KEY_Down = r"""65364"""
KEY_Dstroke = r"""464"""
KEY_E = r"""69"""
KEY_ENG = r"""957"""
KEY_ETH = r"""208"""
KEY_EZH = r"""16777655"""
KEY_Eabovedot = r"""972"""
KEY_Eacute = r"""201"""
KEY_Ebelowdot = r"""16785080"""
KEY_Ecaron = r"""460"""
KEY_Ecircumflex = r"""202"""
KEY_Ecircumflexacute = r"""16785086"""
KEY_Ecircumflexbelowdot = r"""16785094"""
KEY_Ecircumflexgrave = r"""16785088"""
KEY_Ecircumflexhook = r"""16785090"""
KEY_Ecircumflextilde = r"""16785092"""
KEY_EcuSign = r"""16785568"""
KEY_Ediaeresis = r"""203"""
KEY_Egrave = r"""200"""
KEY_Ehook = r"""16785082"""
KEY_Eisu_Shift = r"""65327"""
KEY_Eisu_toggle = r"""65328"""
KEY_Eject = r"""269025068"""
KEY_Emacron = r"""938"""
KEY_End = r"""65367"""
KEY_Eogonek = r"""458"""
KEY_Escape = r"""65307"""
KEY_Eth = r"""208"""
KEY_Etilde = r"""16785084"""
KEY_EuroSign = r"""8364"""
KEY_Excel = r"""269025116"""
KEY_Execute = r"""65378"""
KEY_Explorer = r"""269025117"""
KEY_F = r"""70"""
KEY_F1 = r"""65470"""
KEY_F10 = r"""65479"""
KEY_F11 = r"""65480"""
KEY_F12 = r"""65481"""
KEY_F13 = r"""65482"""
KEY_F14 = r"""65483"""
KEY_F15 = r"""65484"""
KEY_F16 = r"""65485"""
KEY_F17 = r"""65486"""
KEY_F18 = r"""65487"""
KEY_F19 = r"""65488"""
KEY_F2 = r"""65471"""
KEY_F20 = r"""65489"""
KEY_F21 = r"""65490"""
KEY_F22 = r"""65491"""
KEY_F23 = r"""65492"""
KEY_F24 = r"""65493"""
KEY_F25 = r"""65494"""
KEY_F26 = r"""65495"""
KEY_F27 = r"""65496"""
KEY_F28 = r"""65497"""
KEY_F29 = r"""65498"""
KEY_F3 = r"""65472"""
KEY_F30 = r"""65499"""
KEY_F31 = r"""65500"""
KEY_F32 = r"""65501"""
KEY_F33 = r"""65502"""
KEY_F34 = r"""65503"""
KEY_F35 = r"""65504"""
KEY_F4 = r"""65473"""
KEY_F5 = r"""65474"""
KEY_F6 = r"""65475"""
KEY_F7 = r"""65476"""
KEY_F8 = r"""65477"""
KEY_F9 = r"""65478"""
KEY_FFrancSign = r"""16785571"""
KEY_Fabovedot = r"""16784926"""
KEY_Farsi_0 = r"""16778992"""
KEY_Farsi_1 = r"""16778993"""
KEY_Farsi_2 = r"""16778994"""
KEY_Farsi_3 = r"""16778995"""
KEY_Farsi_4 = r"""16778996"""
KEY_Farsi_5 = r"""16778997"""
KEY_Farsi_6 = r"""16778998"""
KEY_Farsi_7 = r"""16778999"""
KEY_Farsi_8 = r"""16779000"""
KEY_Farsi_9 = r"""16779001"""
KEY_Farsi_yeh = r"""16778956"""
KEY_Favorites = r"""269025072"""
KEY_Finance = r"""269025084"""
KEY_Find = r"""65384"""
KEY_First_Virtual_Screen = r"""65232"""
KEY_Forward = r"""269025063"""
KEY_FrameBack = r"""269025181"""
KEY_FrameForward = r"""269025182"""
KEY_G = r"""71"""
KEY_Gabovedot = r"""725"""
KEY_Game = r"""269025118"""
KEY_Gbreve = r"""683"""
KEY_Gcaron = r"""16777702"""
KEY_Gcedilla = r"""939"""
KEY_Gcircumflex = r"""728"""
KEY_Georgian_an = r"""16781520"""
KEY_Georgian_ban = r"""16781521"""
KEY_Georgian_can = r"""16781546"""
KEY_Georgian_char = r"""16781549"""
KEY_Georgian_chin = r"""16781545"""
KEY_Georgian_cil = r"""16781548"""
KEY_Georgian_don = r"""16781523"""
KEY_Georgian_en = r"""16781524"""
KEY_Georgian_fi = r"""16781558"""
KEY_Georgian_gan = r"""16781522"""
KEY_Georgian_ghan = r"""16781542"""
KEY_Georgian_hae = r"""16781552"""
KEY_Georgian_har = r"""16781556"""
KEY_Georgian_he = r"""16781553"""
KEY_Georgian_hie = r"""16781554"""
KEY_Georgian_hoe = r"""16781557"""
KEY_Georgian_in = r"""16781528"""
KEY_Georgian_jhan = r"""16781551"""
KEY_Georgian_jil = r"""16781547"""
KEY_Georgian_kan = r"""16781529"""
KEY_Georgian_khar = r"""16781541"""
KEY_Georgian_las = r"""16781530"""
KEY_Georgian_man = r"""16781531"""
KEY_Georgian_nar = r"""16781532"""
KEY_Georgian_on = r"""16781533"""
KEY_Georgian_par = r"""16781534"""
KEY_Georgian_phar = r"""16781540"""
KEY_Georgian_qar = r"""16781543"""
KEY_Georgian_rae = r"""16781536"""
KEY_Georgian_san = r"""16781537"""
KEY_Georgian_shin = r"""16781544"""
KEY_Georgian_tan = r"""16781527"""
KEY_Georgian_tar = r"""16781538"""
KEY_Georgian_un = r"""16781539"""
KEY_Georgian_vin = r"""16781525"""
KEY_Georgian_we = r"""16781555"""
KEY_Georgian_xan = r"""16781550"""
KEY_Georgian_zen = r"""16781526"""
KEY_Georgian_zhar = r"""16781535"""
KEY_Go = r"""269025119"""
KEY_Greek_ALPHA = r"""1985"""
KEY_Greek_ALPHAaccent = r"""1953"""
KEY_Greek_BETA = r"""1986"""
KEY_Greek_CHI = r"""2007"""
KEY_Greek_DELTA = r"""1988"""
KEY_Greek_EPSILON = r"""1989"""
KEY_Greek_EPSILONaccent = r"""1954"""
KEY_Greek_ETA = r"""1991"""
KEY_Greek_ETAaccent = r"""1955"""
KEY_Greek_GAMMA = r"""1987"""
KEY_Greek_IOTA = r"""1993"""
KEY_Greek_IOTAaccent = r"""1956"""
KEY_Greek_IOTAdiaeresis = r"""1957"""
KEY_Greek_IOTAdieresis = r"""1957"""
KEY_Greek_KAPPA = r"""1994"""
KEY_Greek_LAMBDA = r"""1995"""
KEY_Greek_LAMDA = r"""1995"""
KEY_Greek_MU = r"""1996"""
KEY_Greek_NU = r"""1997"""
KEY_Greek_OMEGA = r"""2009"""
KEY_Greek_OMEGAaccent = r"""1963"""
KEY_Greek_OMICRON = r"""1999"""
KEY_Greek_OMICRONaccent = r"""1959"""
KEY_Greek_PHI = r"""2006"""
KEY_Greek_PI = r"""2000"""
KEY_Greek_PSI = r"""2008"""
KEY_Greek_RHO = r"""2001"""
KEY_Greek_SIGMA = r"""2002"""
KEY_Greek_TAU = r"""2004"""
KEY_Greek_THETA = r"""1992"""
KEY_Greek_UPSILON = r"""2005"""
KEY_Greek_UPSILONaccent = r"""1960"""
KEY_Greek_UPSILONdieresis = r"""1961"""
KEY_Greek_XI = r"""1998"""
KEY_Greek_ZETA = r"""1990"""
KEY_Greek_accentdieresis = r"""1966"""
KEY_Greek_alpha = r"""2017"""
KEY_Greek_alphaaccent = r"""1969"""
KEY_Greek_beta = r"""2018"""
KEY_Greek_chi = r"""2039"""
KEY_Greek_delta = r"""2020"""
KEY_Greek_epsilon = r"""2021"""
KEY_Greek_epsilonaccent = r"""1970"""
KEY_Greek_eta = r"""2023"""
KEY_Greek_etaaccent = r"""1971"""
KEY_Greek_finalsmallsigma = r"""2035"""
KEY_Greek_gamma = r"""2019"""
KEY_Greek_horizbar = r"""1967"""
KEY_Greek_iota = r"""2025"""
KEY_Greek_iotaaccent = r"""1972"""
KEY_Greek_iotaaccentdieresis = r"""1974"""
KEY_Greek_iotadieresis = r"""1973"""
KEY_Greek_kappa = r"""2026"""
KEY_Greek_lambda = r"""2027"""
KEY_Greek_lamda = r"""2027"""
KEY_Greek_mu = r"""2028"""
KEY_Greek_nu = r"""2029"""
KEY_Greek_omega = r"""2041"""
KEY_Greek_omegaaccent = r"""1979"""
KEY_Greek_omicron = r"""2031"""
KEY_Greek_omicronaccent = r"""1975"""
KEY_Greek_phi = r"""2038"""
KEY_Greek_pi = r"""2032"""
KEY_Greek_psi = r"""2040"""
KEY_Greek_rho = r"""2033"""
KEY_Greek_sigma = r"""2034"""
KEY_Greek_switch = r"""65406"""
KEY_Greek_tau = r"""2036"""
KEY_Greek_theta = r"""2024"""
KEY_Greek_upsilon = r"""2037"""
KEY_Greek_upsilonaccent = r"""1976"""
KEY_Greek_upsilonaccentdieresis = r"""1978"""
KEY_Greek_upsilondieresis = r"""1977"""
KEY_Greek_xi = r"""2030"""
KEY_Greek_zeta = r"""2022"""
KEY_Green = r"""269025188"""
KEY_H = r"""72"""
KEY_Hangul = r"""65329"""
KEY_Hangul_A = r"""3775"""
KEY_Hangul_AE = r"""3776"""
KEY_Hangul_AraeA = r"""3830"""
KEY_Hangul_AraeAE = r"""3831"""
KEY_Hangul_Banja = r"""65337"""
KEY_Hangul_Cieuc = r"""3770"""
KEY_Hangul_Codeinput = r"""65335"""
KEY_Hangul_Dikeud = r"""3751"""
KEY_Hangul_E = r"""3780"""
KEY_Hangul_EO = r"""3779"""
KEY_Hangul_EU = r"""3793"""
KEY_Hangul_End = r"""65331"""
KEY_Hangul_Hanja = r"""65332"""
KEY_Hangul_Hieuh = r"""3774"""
KEY_Hangul_I = r"""3795"""
KEY_Hangul_Ieung = r"""3767"""
KEY_Hangul_J_Cieuc = r"""3818"""
KEY_Hangul_J_Dikeud = r"""3802"""
KEY_Hangul_J_Hieuh = r"""3822"""
KEY_Hangul_J_Ieung = r"""3816"""
KEY_Hangul_J_Jieuj = r"""3817"""
KEY_Hangul_J_Khieuq = r"""3819"""
KEY_Hangul_J_Kiyeog = r"""3796"""
KEY_Hangul_J_KiyeogSios = r"""3798"""
KEY_Hangul_J_KkogjiDalrinIeung = r"""3833"""
KEY_Hangul_J_Mieum = r"""3811"""
KEY_Hangul_J_Nieun = r"""3799"""
KEY_Hangul_J_NieunHieuh = r"""3801"""
KEY_Hangul_J_NieunJieuj = r"""3800"""
KEY_Hangul_J_PanSios = r"""3832"""
KEY_Hangul_J_Phieuf = r"""3821"""
KEY_Hangul_J_Pieub = r"""3812"""
KEY_Hangul_J_PieubSios = r"""3813"""
KEY_Hangul_J_Rieul = r"""3803"""
KEY_Hangul_J_RieulHieuh = r"""3810"""
KEY_Hangul_J_RieulKiyeog = r"""3804"""
KEY_Hangul_J_RieulMieum = r"""3805"""
KEY_Hangul_J_RieulPhieuf = r"""3809"""
KEY_Hangul_J_RieulPieub = r"""3806"""
KEY_Hangul_J_RieulSios = r"""3807"""
KEY_Hangul_J_RieulTieut = r"""3808"""
KEY_Hangul_J_Sios = r"""3814"""
KEY_Hangul_J_SsangKiyeog = r"""3797"""
KEY_Hangul_J_SsangSios = r"""3815"""
KEY_Hangul_J_Tieut = r"""3820"""
KEY_Hangul_J_YeorinHieuh = r"""3834"""
KEY_Hangul_Jamo = r"""65333"""
KEY_Hangul_Jeonja = r"""65336"""
KEY_Hangul_Jieuj = r"""3768"""
KEY_Hangul_Khieuq = r"""3771"""
KEY_Hangul_Kiyeog = r"""3745"""
KEY_Hangul_KiyeogSios = r"""3747"""
KEY_Hangul_KkogjiDalrinIeung = r"""3827"""
KEY_Hangul_Mieum = r"""3761"""
KEY_Hangul_MultipleCandidate = r"""65341"""
KEY_Hangul_Nieun = r"""3748"""
KEY_Hangul_NieunHieuh = r"""3750"""
KEY_Hangul_NieunJieuj = r"""3749"""
KEY_Hangul_O = r"""3783"""
KEY_Hangul_OE = r"""3786"""
KEY_Hangul_PanSios = r"""3826"""
KEY_Hangul_Phieuf = r"""3773"""
KEY_Hangul_Pieub = r"""3762"""
KEY_Hangul_PieubSios = r"""3764"""
KEY_Hangul_PostHanja = r"""65339"""
KEY_Hangul_PreHanja = r"""65338"""
KEY_Hangul_PreviousCandidate = r"""65342"""
KEY_Hangul_Rieul = r"""3753"""
KEY_Hangul_RieulHieuh = r"""3760"""
KEY_Hangul_RieulKiyeog = r"""3754"""
KEY_Hangul_RieulMieum = r"""3755"""
KEY_Hangul_RieulPhieuf = r"""3759"""
KEY_Hangul_RieulPieub = r"""3756"""
KEY_Hangul_RieulSios = r"""3757"""
KEY_Hangul_RieulTieut = r"""3758"""
KEY_Hangul_RieulYeorinHieuh = r"""3823"""
KEY_Hangul_Romaja = r"""65334"""
KEY_Hangul_SingleCandidate = r"""65340"""
KEY_Hangul_Sios = r"""3765"""
KEY_Hangul_Special = r"""65343"""
KEY_Hangul_SsangDikeud = r"""3752"""
KEY_Hangul_SsangJieuj = r"""3769"""
KEY_Hangul_SsangKiyeog = r"""3746"""
KEY_Hangul_SsangPieub = r"""3763"""
KEY_Hangul_SsangSios = r"""3766"""
KEY_Hangul_Start = r"""65330"""
KEY_Hangul_SunkyeongeumMieum = r"""3824"""
KEY_Hangul_SunkyeongeumPhieuf = r"""3828"""
KEY_Hangul_SunkyeongeumPieub = r"""3825"""
KEY_Hangul_Tieut = r"""3772"""
KEY_Hangul_U = r"""3788"""
KEY_Hangul_WA = r"""3784"""
KEY_Hangul_WAE = r"""3785"""
KEY_Hangul_WE = r"""3790"""
KEY_Hangul_WEO = r"""3789"""
KEY_Hangul_WI = r"""3791"""
KEY_Hangul_YA = r"""3777"""
KEY_Hangul_YAE = r"""3778"""
KEY_Hangul_YE = r"""3782"""
KEY_Hangul_YEO = r"""3781"""
KEY_Hangul_YI = r"""3794"""
KEY_Hangul_YO = r"""3787"""
KEY_Hangul_YU = r"""3792"""
KEY_Hangul_YeorinHieuh = r"""3829"""
KEY_Hangul_switch = r"""65406"""
KEY_Hankaku = r"""65321"""
KEY_Hcircumflex = r"""678"""
KEY_Hebrew_switch = r"""65406"""
KEY_Help = r"""65386"""
KEY_Henkan = r"""65315"""
KEY_Henkan_Mode = r"""65315"""
KEY_Hibernate = r"""269025192"""
KEY_Hiragana = r"""65317"""
KEY_Hiragana_Katakana = r"""65319"""
KEY_History = r"""269025079"""
KEY_Home = r"""65360"""
KEY_HomePage = r"""269025048"""
KEY_HotLinks = r"""269025082"""
KEY_Hstroke = r"""673"""
KEY_Hyper_L = r"""65517"""
KEY_Hyper_R = r"""65518"""
KEY_I = r"""73"""
KEY_ISO_Center_Object = r"""65075"""
KEY_ISO_Continuous_Underline = r"""65072"""
KEY_ISO_Discontinuous_Underline = r"""65073"""
KEY_ISO_Emphasize = r"""65074"""
KEY_ISO_Enter = r"""65076"""
KEY_ISO_Fast_Cursor_Down = r"""65071"""
KEY_ISO_Fast_Cursor_Left = r"""65068"""
KEY_ISO_Fast_Cursor_Right = r"""65069"""
KEY_ISO_Fast_Cursor_Up = r"""65070"""
KEY_ISO_First_Group = r"""65036"""
KEY_ISO_First_Group_Lock = r"""65037"""
KEY_ISO_Group_Latch = r"""65030"""
KEY_ISO_Group_Lock = r"""65031"""
KEY_ISO_Group_Shift = r"""65406"""
KEY_ISO_Last_Group = r"""65038"""
KEY_ISO_Last_Group_Lock = r"""65039"""
KEY_ISO_Left_Tab = r"""65056"""
KEY_ISO_Level2_Latch = r"""65026"""
KEY_ISO_Level3_Latch = r"""65028"""
KEY_ISO_Level3_Lock = r"""65029"""
KEY_ISO_Level3_Shift = r"""65027"""
KEY_ISO_Level5_Latch = r"""65042"""
KEY_ISO_Level5_Lock = r"""65043"""
KEY_ISO_Level5_Shift = r"""65041"""
KEY_ISO_Lock = r"""65025"""
KEY_ISO_Move_Line_Down = r"""65058"""
KEY_ISO_Move_Line_Up = r"""65057"""
KEY_ISO_Next_Group = r"""65032"""
KEY_ISO_Next_Group_Lock = r"""65033"""
KEY_ISO_Partial_Line_Down = r"""65060"""
KEY_ISO_Partial_Line_Up = r"""65059"""
KEY_ISO_Partial_Space_Left = r"""65061"""
KEY_ISO_Partial_Space_Right = r"""65062"""
KEY_ISO_Prev_Group = r"""65034"""
KEY_ISO_Prev_Group_Lock = r"""65035"""
KEY_ISO_Release_Both_Margins = r"""65067"""
KEY_ISO_Release_Margin_Left = r"""65065"""
KEY_ISO_Release_Margin_Right = r"""65066"""
KEY_ISO_Set_Margin_Left = r"""65063"""
KEY_ISO_Set_Margin_Right = r"""65064"""
KEY_Iabovedot = r"""681"""
KEY_Iacute = r"""205"""
KEY_Ibelowdot = r"""16785098"""
KEY_Ibreve = r"""16777516"""
KEY_Icircumflex = r"""206"""
KEY_Idiaeresis = r"""207"""
KEY_Igrave = r"""204"""
KEY_Ihook = r"""16785096"""
KEY_Imacron = r"""975"""
KEY_Insert = r"""65379"""
KEY_Iogonek = r"""967"""
KEY_Itilde = r"""933"""
KEY_J = r"""74"""
KEY_Jcircumflex = r"""684"""
KEY_K = r"""75"""
KEY_KP_0 = r"""65456"""
KEY_KP_1 = r"""65457"""
KEY_KP_2 = r"""65458"""
KEY_KP_3 = r"""65459"""
KEY_KP_4 = r"""65460"""
KEY_KP_5 = r"""65461"""
KEY_KP_6 = r"""65462"""
KEY_KP_7 = r"""65463"""
KEY_KP_8 = r"""65464"""
KEY_KP_9 = r"""65465"""
KEY_KP_Add = r"""65451"""
KEY_KP_Begin = r"""65437"""
KEY_KP_Decimal = r"""65454"""
KEY_KP_Delete = r"""65439"""
KEY_KP_Divide = r"""65455"""
KEY_KP_Down = r"""65433"""
KEY_KP_End = r"""65436"""
KEY_KP_Enter = r"""65421"""
KEY_KP_Equal = r"""65469"""
KEY_KP_F1 = r"""65425"""
KEY_KP_F2 = r"""65426"""
KEY_KP_F3 = r"""65427"""
KEY_KP_F4 = r"""65428"""
KEY_KP_Home = r"""65429"""
KEY_KP_Insert = r"""65438"""
KEY_KP_Left = r"""65430"""
KEY_KP_Multiply = r"""65450"""
KEY_KP_Next = r"""65435"""
KEY_KP_Page_Down = r"""65435"""
KEY_KP_Page_Up = r"""65434"""
KEY_KP_Prior = r"""65434"""
KEY_KP_Right = r"""65432"""
KEY_KP_Separator = r"""65452"""
KEY_KP_Space = r"""65408"""
KEY_KP_Subtract = r"""65453"""
KEY_KP_Tab = r"""65417"""
KEY_KP_Up = r"""65431"""
KEY_Kana_Lock = r"""65325"""
KEY_Kana_Shift = r"""65326"""
KEY_Kanji = r"""65313"""
KEY_Kanji_Bangou = r"""65335"""
KEY_Katakana = r"""65318"""
KEY_KbdBrightnessDown = r"""269025030"""
KEY_KbdBrightnessUp = r"""269025029"""
KEY_KbdLightOnOff = r"""269025028"""
KEY_Kcedilla = r"""979"""
KEY_Korean_Won = r"""3839"""
KEY_L = r"""76"""
KEY_L1 = r"""65480"""
KEY_L10 = r"""65489"""
KEY_L2 = r"""65481"""
KEY_L3 = r"""65482"""
KEY_L4 = r"""65483"""
KEY_L5 = r"""65484"""
KEY_L6 = r"""65485"""
KEY_L7 = r"""65486"""
KEY_L8 = r"""65487"""
KEY_L9 = r"""65488"""
KEY_Lacute = r"""453"""
KEY_Last_Virtual_Screen = r"""65236"""
KEY_Launch0 = r"""269025088"""
KEY_Launch1 = r"""269025089"""
KEY_Launch2 = r"""269025090"""
KEY_Launch3 = r"""269025091"""
KEY_Launch4 = r"""269025092"""
KEY_Launch5 = r"""269025093"""
KEY_Launch6 = r"""269025094"""
KEY_Launch7 = r"""269025095"""
KEY_Launch8 = r"""269025096"""
KEY_Launch9 = r"""269025097"""
KEY_LaunchA = r"""269025098"""
KEY_LaunchB = r"""269025099"""
KEY_LaunchC = r"""269025100"""
KEY_LaunchD = r"""269025101"""
KEY_LaunchE = r"""269025102"""
KEY_LaunchF = r"""269025103"""
KEY_Lbelowdot = r"""16784950"""
KEY_Lcaron = r"""421"""
KEY_Lcedilla = r"""934"""
KEY_Left = r"""65361"""
KEY_LightBulb = r"""269025077"""
KEY_Linefeed = r"""65290"""
KEY_LiraSign = r"""16785572"""
KEY_LogGrabInfo = r"""269024805"""
KEY_LogOff = r"""269025121"""
KEY_LogWindowTree = r"""269024804"""
KEY_Lstroke = r"""419"""
KEY_M = r"""77"""
KEY_Mabovedot = r"""16784960"""
KEY_Macedonia_DSE = r"""1717"""
KEY_Macedonia_GJE = r"""1714"""
KEY_Macedonia_KJE = r"""1724"""
KEY_Macedonia_dse = r"""1701"""
KEY_Macedonia_gje = r"""1698"""
KEY_Macedonia_kje = r"""1708"""
KEY_Mae_Koho = r"""65342"""
KEY_Mail = r"""269025049"""
KEY_MailForward = r"""269025168"""
KEY_Market = r"""269025122"""
KEY_Massyo = r"""65324"""
KEY_Meeting = r"""269025123"""
KEY_Memo = r"""269025054"""
KEY_Menu = r"""65383"""
KEY_MenuKB = r"""269025125"""
KEY_MenuPB = r"""269025126"""
KEY_Messenger = r"""269025166"""
KEY_Meta_L = r"""65511"""
KEY_Meta_R = r"""65512"""
KEY_MillSign = r"""16785573"""
KEY_ModeLock = r"""269025025"""
KEY_Mode_switch = r"""65406"""
KEY_MonBrightnessDown = r"""269025027"""
KEY_MonBrightnessUp = r"""269025026"""
KEY_MouseKeys_Accel_Enable = r"""65143"""
KEY_MouseKeys_Enable = r"""65142"""
KEY_Muhenkan = r"""65314"""
KEY_Multi_key = r"""65312"""
KEY_MultipleCandidate = r"""65341"""
KEY_Music = r"""269025170"""
KEY_MyComputer = r"""269025075"""
KEY_MySites = r"""269025127"""
KEY_N = r"""78"""
KEY_Nacute = r"""465"""
KEY_NairaSign = r"""16785574"""
KEY_Ncaron = r"""466"""
KEY_Ncedilla = r"""977"""
KEY_New = r"""269025128"""
KEY_NewSheqelSign = r"""16785578"""
KEY_News = r"""269025129"""
KEY_Next = r"""65366"""
KEY_Next_VMode = r"""269024802"""
KEY_Next_Virtual_Screen = r"""65234"""
KEY_Ntilde = r"""209"""
KEY_Num_Lock = r"""65407"""
KEY_O = r"""79"""
KEY_OE = r"""5052"""
KEY_Oacute = r"""211"""
KEY_Obarred = r"""16777631"""
KEY_Obelowdot = r"""16785100"""
KEY_Ocaron = r"""16777681"""
KEY_Ocircumflex = r"""212"""
KEY_Ocircumflexacute = r"""16785104"""
KEY_Ocircumflexbelowdot = r"""16785112"""
KEY_Ocircumflexgrave = r"""16785106"""
KEY_Ocircumflexhook = r"""16785108"""
KEY_Ocircumflextilde = r"""16785110"""
KEY_Odiaeresis = r"""214"""
KEY_Odoubleacute = r"""469"""
KEY_OfficeHome = r"""269025130"""
KEY_Ograve = r"""210"""
KEY_Ohook = r"""16785102"""
KEY_Ohorn = r"""16777632"""
KEY_Ohornacute = r"""16785114"""
KEY_Ohornbelowdot = r"""16785122"""
KEY_Ohorngrave = r"""16785116"""
KEY_Ohornhook = r"""16785118"""
KEY_Ohorntilde = r"""16785120"""
KEY_Omacron = r"""978"""
KEY_Ooblique = r"""216"""
KEY_Open = r"""269025131"""
KEY_OpenURL = r"""269025080"""
KEY_Option = r"""269025132"""
KEY_Oslash = r"""216"""
KEY_Otilde = r"""213"""
KEY_Overlay1_Enable = r"""65144"""
KEY_Overlay2_Enable = r"""65145"""
KEY_P = r"""80"""
KEY_Pabovedot = r"""16784982"""
KEY_Page_Down = r"""65366"""
KEY_Page_Up = r"""65365"""
KEY_Paste = r"""269025133"""
KEY_Pause = r"""65299"""
KEY_PesetaSign = r"""16785575"""
KEY_Phone = r"""269025134"""
KEY_Pictures = r"""269025169"""
KEY_Pointer_Accelerate = r"""65274"""
KEY_Pointer_Button1 = r"""65257"""
KEY_Pointer_Button2 = r"""65258"""
KEY_Pointer_Button3 = r"""65259"""
KEY_Pointer_Button4 = r"""65260"""
KEY_Pointer_Button5 = r"""65261"""
KEY_Pointer_Button_Dflt = r"""65256"""
KEY_Pointer_DblClick1 = r"""65263"""
KEY_Pointer_DblClick2 = r"""65264"""
KEY_Pointer_DblClick3 = r"""65265"""
KEY_Pointer_DblClick4 = r"""65266"""
KEY_Pointer_DblClick5 = r"""65267"""
KEY_Pointer_DblClick_Dflt = r"""65262"""
KEY_Pointer_DfltBtnNext = r"""65275"""
KEY_Pointer_DfltBtnPrev = r"""65276"""
KEY_Pointer_Down = r"""65251"""
KEY_Pointer_DownLeft = r"""65254"""
KEY_Pointer_DownRight = r"""65255"""
KEY_Pointer_Drag1 = r"""65269"""
KEY_Pointer_Drag2 = r"""65270"""
KEY_Pointer_Drag3 = r"""65271"""
KEY_Pointer_Drag4 = r"""65272"""
KEY_Pointer_Drag5 = r"""65277"""
KEY_Pointer_Drag_Dflt = r"""65268"""
KEY_Pointer_EnableKeys = r"""65273"""
KEY_Pointer_Left = r"""65248"""
KEY_Pointer_Right = r"""65249"""
KEY_Pointer_Up = r"""65250"""
KEY_Pointer_UpLeft = r"""65252"""
KEY_Pointer_UpRight = r"""65253"""
KEY_PowerDown = r"""269025057"""
KEY_PowerOff = r"""269025066"""
KEY_Prev_VMode = r"""269024803"""
KEY_Prev_Virtual_Screen = r"""65233"""
KEY_PreviousCandidate = r"""65342"""
KEY_Print = r"""65377"""
KEY_Prior = r"""65365"""
KEY_Q = r"""81"""
KEY_R = r"""82"""
KEY_R1 = r"""65490"""
KEY_R10 = r"""65499"""
KEY_R11 = r"""65500"""
KEY_R12 = r"""65501"""
KEY_R13 = r"""65502"""
KEY_R14 = r"""65503"""
KEY_R15 = r"""65504"""
KEY_R2 = r"""65491"""
KEY_R3 = r"""65492"""
KEY_R4 = r"""65493"""
KEY_R5 = r"""65494"""
KEY_R6 = r"""65495"""
KEY_R7 = r"""65496"""
KEY_R8 = r"""65497"""
KEY_R9 = r"""65498"""
KEY_Racute = r"""448"""
KEY_Rcaron = r"""472"""
KEY_Rcedilla = r"""931"""
KEY_Red = r"""269025187"""
KEY_Redo = r"""65382"""
KEY_Refresh = r"""269025065"""
KEY_Reload = r"""269025139"""
KEY_RepeatKeys_Enable = r"""65138"""
KEY_Reply = r"""269025138"""
KEY_Return = r"""65293"""
KEY_Right = r"""65363"""
KEY_RockerDown = r"""269025060"""
KEY_RockerEnter = r"""269025061"""
KEY_RockerUp = r"""269025059"""
KEY_Romaji = r"""65316"""
KEY_RotateWindows = r"""269025140"""
KEY_RotationKB = r"""269025142"""
KEY_RotationPB = r"""269025141"""
KEY_RupeeSign = r"""16785576"""
KEY_S = r"""83"""
KEY_SCHWA = r"""16777615"""
KEY_Sabovedot = r"""16784992"""
KEY_Sacute = r"""422"""
KEY_Save = r"""269025143"""
KEY_Scaron = r"""425"""
KEY_Scedilla = r"""426"""
KEY_Scircumflex = r"""734"""
KEY_ScreenSaver = r"""269025069"""
KEY_ScrollClick = r"""269025146"""
KEY_ScrollDown = r"""269025145"""
KEY_ScrollUp = r"""269025144"""
KEY_Scroll_Lock = r"""65300"""
KEY_Search = r"""269025051"""
KEY_Select = r"""65376"""
KEY_SelectButton = r"""269025184"""
KEY_Send = r"""269025147"""
KEY_Serbian_DJE = r"""1713"""
KEY_Serbian_DZE = r"""1727"""
KEY_Serbian_JE = r"""1720"""
KEY_Serbian_LJE = r"""1721"""
KEY_Serbian_NJE = r"""1722"""
KEY_Serbian_TSHE = r"""1723"""
KEY_Serbian_dje = r"""1697"""
KEY_Serbian_dze = r"""1711"""
KEY_Serbian_je = r"""1704"""
KEY_Serbian_lje = r"""1705"""
KEY_Serbian_nje = r"""1706"""
KEY_Serbian_tshe = r"""1707"""
KEY_Shift_L = r"""65505"""
KEY_Shift_Lock = r"""65510"""
KEY_Shift_R = r"""65506"""
KEY_Shop = r"""269025078"""
KEY_SingleCandidate = r"""65340"""
KEY_Sinh_a = r"""16780677"""
KEY_Sinh_aa = r"""16780678"""
KEY_Sinh_aa2 = r"""16780751"""
KEY_Sinh_ae = r"""16780679"""
KEY_Sinh_ae2 = r"""16780752"""
KEY_Sinh_aee = r"""16780680"""
KEY_Sinh_aee2 = r"""16780753"""
KEY_Sinh_ai = r"""16780691"""
KEY_Sinh_ai2 = r"""16780763"""
KEY_Sinh_al = r"""16780746"""
KEY_Sinh_au = r"""16780694"""
KEY_Sinh_au2 = r"""16780766"""
KEY_Sinh_ba = r"""16780726"""
KEY_Sinh_bha = r"""16780727"""
KEY_Sinh_ca = r"""16780704"""
KEY_Sinh_cha = r"""16780705"""
KEY_Sinh_dda = r"""16780713"""
KEY_Sinh_ddha = r"""16780714"""
KEY_Sinh_dha = r"""16780719"""
KEY_Sinh_dhha = r"""16780720"""
KEY_Sinh_e = r"""16780689"""
KEY_Sinh_e2 = r"""16780761"""
KEY_Sinh_ee = r"""16780690"""
KEY_Sinh_ee2 = r"""16780762"""
KEY_Sinh_fa = r"""16780742"""
KEY_Sinh_ga = r"""16780700"""
KEY_Sinh_gha = r"""16780701"""
KEY_Sinh_h2 = r"""16780675"""
KEY_Sinh_ha = r"""16780740"""
KEY_Sinh_i = r"""16780681"""
KEY_Sinh_i2 = r"""16780754"""
KEY_Sinh_ii = r"""16780682"""
KEY_Sinh_ii2 = r"""16780755"""
KEY_Sinh_ja = r"""16780706"""
KEY_Sinh_jha = r"""16780707"""
KEY_Sinh_jnya = r"""16780709"""
KEY_Sinh_ka = r"""16780698"""
KEY_Sinh_kha = r"""16780699"""
KEY_Sinh_kunddaliya = r"""16780788"""
KEY_Sinh_la = r"""16780733"""
KEY_Sinh_lla = r"""16780741"""
KEY_Sinh_lu = r"""16780687"""
KEY_Sinh_lu2 = r"""16780767"""
KEY_Sinh_luu = r"""16780688"""
KEY_Sinh_luu2 = r"""16780787"""
KEY_Sinh_ma = r"""16780728"""
KEY_Sinh_mba = r"""16780729"""
KEY_Sinh_na = r"""16780721"""
KEY_Sinh_ndda = r"""16780716"""
KEY_Sinh_ndha = r"""16780723"""
KEY_Sinh_ng = r"""16780674"""
KEY_Sinh_ng2 = r"""16780702"""
KEY_Sinh_nga = r"""16780703"""
KEY_Sinh_nja = r"""16780710"""
KEY_Sinh_nna = r"""16780715"""
KEY_Sinh_nya = r"""16780708"""
KEY_Sinh_o = r"""16780692"""
KEY_Sinh_o2 = r"""16780764"""
KEY_Sinh_oo = r"""16780693"""
KEY_Sinh_oo2 = r"""16780765"""
KEY_Sinh_pa = r"""16780724"""
KEY_Sinh_pha = r"""16780725"""
KEY_Sinh_ra = r"""16780731"""
KEY_Sinh_ri = r"""16780685"""
KEY_Sinh_rii = r"""16780686"""
KEY_Sinh_ru2 = r"""16780760"""
KEY_Sinh_ruu2 = r"""16780786"""
KEY_Sinh_sa = r"""16780739"""
KEY_Sinh_sha = r"""16780737"""
KEY_Sinh_ssha = r"""16780738"""
KEY_Sinh_tha = r"""16780717"""
KEY_Sinh_thha = r"""16780718"""
KEY_Sinh_tta = r"""16780711"""
KEY_Sinh_ttha = r"""16780712"""
KEY_Sinh_u = r"""16780683"""
KEY_Sinh_u2 = r"""16780756"""
KEY_Sinh_uu = r"""16780684"""
KEY_Sinh_uu2 = r"""16780758"""
KEY_Sinh_va = r"""16780736"""
KEY_Sinh_ya = r"""16780730"""
KEY_Sleep = r"""269025071"""
KEY_SlowKeys_Enable = r"""65139"""
KEY_Spell = r"""269025148"""
KEY_SplitScreen = r"""269025149"""
KEY_Standby = r"""269025040"""
KEY_Start = r"""269025050"""
KEY_StickyKeys_Enable = r"""65141"""
KEY_Stop = r"""269025064"""
KEY_Subtitle = r"""269025178"""
KEY_Super_L = r"""65515"""
KEY_Super_R = r"""65516"""
KEY_Support = r"""269025150"""
KEY_Suspend = r"""269025191"""
KEY_Switch_VT_1 = r"""269024769"""
KEY_Switch_VT_10 = r"""269024778"""
KEY_Switch_VT_11 = r"""269024779"""
KEY_Switch_VT_12 = r"""269024780"""
KEY_Switch_VT_2 = r"""269024770"""
KEY_Switch_VT_3 = r"""269024771"""
KEY_Switch_VT_4 = r"""269024772"""
KEY_Switch_VT_5 = r"""269024773"""
KEY_Switch_VT_6 = r"""269024774"""
KEY_Switch_VT_7 = r"""269024775"""
KEY_Switch_VT_8 = r"""269024776"""
KEY_Switch_VT_9 = r"""269024777"""
KEY_Sys_Req = r"""65301"""
KEY_T = r"""84"""
KEY_THORN = r"""222"""
KEY_Tab = r"""65289"""
KEY_Tabovedot = r"""16785002"""
KEY_TaskPane = r"""269025151"""
KEY_Tcaron = r"""427"""
KEY_Tcedilla = r"""478"""
KEY_Terminal = r"""269025152"""
KEY_Terminate_Server = r"""65237"""
KEY_Thai_baht = r"""3551"""
KEY_Thai_bobaimai = r"""3514"""
KEY_Thai_chochan = r"""3496"""
KEY_Thai_chochang = r"""3498"""
KEY_Thai_choching = r"""3497"""
KEY_Thai_chochoe = r"""3500"""
KEY_Thai_dochada = r"""3502"""
KEY_Thai_dodek = r"""3508"""
KEY_Thai_fofa = r"""3517"""
KEY_Thai_fofan = r"""3519"""
KEY_Thai_hohip = r"""3531"""
KEY_Thai_honokhuk = r"""3534"""
KEY_Thai_khokhai = r"""3490"""
KEY_Thai_khokhon = r"""3493"""
KEY_Thai_khokhuat = r"""3491"""
KEY_Thai_khokhwai = r"""3492"""
KEY_Thai_khorakhang = r"""3494"""
KEY_Thai_kokai = r"""3489"""
KEY_Thai_lakkhangyao = r"""3557"""
KEY_Thai_lekchet = r"""3575"""
KEY_Thai_lekha = r"""3573"""
KEY_Thai_lekhok = r"""3574"""
KEY_Thai_lekkao = r"""3577"""
KEY_Thai_leknung = r"""3569"""
KEY_Thai_lekpaet = r"""3576"""
KEY_Thai_leksam = r"""3571"""
KEY_Thai_leksi = r"""3572"""
KEY_Thai_leksong = r"""3570"""
KEY_Thai_leksun = r"""3568"""
KEY_Thai_lochula = r"""3532"""
KEY_Thai_loling = r"""3525"""
KEY_Thai_lu = r"""3526"""
KEY_Thai_maichattawa = r"""3563"""
KEY_Thai_maiek = r"""3560"""
KEY_Thai_maihanakat = r"""3537"""
KEY_Thai_maihanakat_maitho = r"""3550"""
KEY_Thai_maitaikhu = r"""3559"""
KEY_Thai_maitho = r"""3561"""
KEY_Thai_maitri = r"""3562"""
KEY_Thai_maiyamok = r"""3558"""
KEY_Thai_moma = r"""3521"""
KEY_Thai_ngongu = r"""3495"""
KEY_Thai_nikhahit = r"""3565"""
KEY_Thai_nonen = r"""3507"""
KEY_Thai_nonu = r"""3513"""
KEY_Thai_oang = r"""3533"""
KEY_Thai_paiyannoi = r"""3535"""
KEY_Thai_phinthu = r"""3546"""
KEY_Thai_phophan = r"""3518"""
KEY_Thai_phophung = r"""3516"""
KEY_Thai_phosamphao = r"""3520"""
KEY_Thai_popla = r"""3515"""
KEY_Thai_rorua = r"""3523"""
KEY_Thai_ru = r"""3524"""
KEY_Thai_saraa = r"""3536"""
KEY_Thai_saraaa = r"""3538"""
KEY_Thai_saraae = r"""3553"""
KEY_Thai_saraaimaimalai = r"""3556"""
KEY_Thai_saraaimaimuan = r"""3555"""
KEY_Thai_saraam = r"""3539"""
KEY_Thai_sarae = r"""3552"""
KEY_Thai_sarai = r"""3540"""
KEY_Thai_saraii = r"""3541"""
KEY_Thai_sarao = r"""3554"""
KEY_Thai_sarau = r"""3544"""
KEY_Thai_saraue = r"""3542"""
KEY_Thai_sarauee = r"""3543"""
KEY_Thai_sarauu = r"""3545"""
KEY_Thai_sorusi = r"""3529"""
KEY_Thai_sosala = r"""3528"""
KEY_Thai_soso = r"""3499"""
KEY_Thai_sosua = r"""3530"""
KEY_Thai_thanthakhat = r"""3564"""
KEY_Thai_thonangmontho = r"""3505"""
KEY_Thai_thophuthao = r"""3506"""
KEY_Thai_thothahan = r"""3511"""
KEY_Thai_thothan = r"""3504"""
KEY_Thai_thothong = r"""3512"""
KEY_Thai_thothung = r"""3510"""
KEY_Thai_topatak = r"""3503"""
KEY_Thai_totao = r"""3509"""
KEY_Thai_wowaen = r"""3527"""
KEY_Thai_yoyak = r"""3522"""
KEY_Thai_yoying = r"""3501"""
KEY_Thorn = r"""222"""
KEY_Time = r"""269025183"""
KEY_ToDoList = r"""269025055"""
KEY_Tools = r"""269025153"""
KEY_TopMenu = r"""269025186"""
KEY_TouchpadOff = r"""269025201"""
KEY_TouchpadOn = r"""269025200"""
KEY_TouchpadToggle = r"""269025193"""
KEY_Touroku = r"""65323"""
KEY_Travel = r"""269025154"""
KEY_Tslash = r"""940"""
KEY_U = r"""85"""
KEY_UWB = r"""269025174"""
KEY_Uacute = r"""218"""
KEY_Ubelowdot = r"""16785124"""
KEY_Ubreve = r"""733"""
KEY_Ucircumflex = r"""219"""
KEY_Udiaeresis = r"""220"""
KEY_Udoubleacute = r"""475"""
KEY_Ugrave = r"""217"""
KEY_Uhook = r"""16785126"""
KEY_Uhorn = r"""16777647"""
KEY_Uhornacute = r"""16785128"""
KEY_Uhornbelowdot = r"""16785136"""
KEY_Uhorngrave = r"""16785130"""
KEY_Uhornhook = r"""16785132"""
KEY_Uhorntilde = r"""16785134"""
KEY_Ukrainian_GHE_WITH_UPTURN = r"""1725"""
KEY_Ukrainian_I = r"""1718"""
KEY_Ukrainian_IE = r"""1716"""
KEY_Ukrainian_YI = r"""1719"""
KEY_Ukrainian_ghe_with_upturn = r"""1709"""
KEY_Ukrainian_i = r"""1702"""
KEY_Ukrainian_ie = r"""1700"""
KEY_Ukrainian_yi = r"""1703"""
KEY_Ukranian_I = r"""1718"""
KEY_Ukranian_JE = r"""1716"""
KEY_Ukranian_YI = r"""1719"""
KEY_Ukranian_i = r"""1702"""
KEY_Ukranian_je = r"""1700"""
KEY_Ukranian_yi = r"""1703"""
KEY_Umacron = r"""990"""
KEY_Undo = r"""65381"""
KEY_Ungrab = r"""269024800"""
KEY_Uogonek = r"""985"""
KEY_Up = r"""65362"""
KEY_Uring = r"""473"""
KEY_User1KB = r"""269025157"""
KEY_User2KB = r"""269025158"""
KEY_UserPB = r"""269025156"""
KEY_Utilde = r"""989"""
KEY_V = r"""86"""
KEY_VendorHome = r"""269025076"""
KEY_Video = r"""269025159"""
KEY_View = r"""269025185"""
KEY_VoidSymbol = r"""16777215"""
KEY_W = r"""87"""
KEY_WLAN = r"""269025173"""
KEY_WWW = r"""269025070"""
KEY_Wacute = r"""16785026"""
KEY_WakeUp = r"""269025067"""
KEY_Wcircumflex = r"""16777588"""
KEY_Wdiaeresis = r"""16785028"""
KEY_WebCam = r"""269025167"""
KEY_Wgrave = r"""16785024"""
KEY_WheelButton = r"""269025160"""
KEY_WindowClear = r"""269025109"""
KEY_WonSign = r"""16785577"""
KEY_Word = r"""269025161"""
KEY_X = r"""88"""
KEY_Xabovedot = r"""16785034"""
KEY_Xfer = r"""269025162"""
KEY_Y = r"""89"""
KEY_Yacute = r"""221"""
KEY_Ybelowdot = r"""16785140"""
KEY_Ycircumflex = r"""16777590"""
KEY_Ydiaeresis = r"""5054"""
KEY_Yellow = r"""269025189"""
KEY_Ygrave = r"""16785138"""
KEY_Yhook = r"""16785142"""
KEY_Ytilde = r"""16785144"""
KEY_Z = r"""90"""
KEY_Zabovedot = r"""431"""
KEY_Zacute = r"""428"""
KEY_Zcaron = r"""430"""
KEY_Zen_Koho = r"""65341"""
KEY_Zenkaku = r"""65320"""
KEY_Zenkaku_Hankaku = r"""65322"""
KEY_ZoomIn = r"""269025163"""
KEY_ZoomOut = r"""269025164"""
KEY_Zstroke = r"""16777653"""
KEY_a = r"""97"""
KEY_aacute = r"""225"""
KEY_abelowdot = r"""16785057"""
KEY_abovedot = r"""511"""
KEY_abreve = r"""483"""
KEY_abreveacute = r"""16785071"""
KEY_abrevebelowdot = r"""16785079"""
KEY_abrevegrave = r"""16785073"""
KEY_abrevehook = r"""16785075"""
KEY_abrevetilde = r"""16785077"""
KEY_acircumflex = r"""226"""
KEY_acircumflexacute = r"""16785061"""
KEY_acircumflexbelowdot = r"""16785069"""
KEY_acircumflexgrave = r"""16785063"""
KEY_acircumflexhook = r"""16785065"""
KEY_acircumflextilde = r"""16785067"""
KEY_acute = r"""180"""
KEY_adiaeresis = r"""228"""
KEY_ae = r"""230"""
KEY_agrave = r"""224"""
KEY_ahook = r"""16785059"""
KEY_amacron = r"""992"""
KEY_ampersand = r"""38"""
KEY_aogonek = r"""433"""
KEY_apostrophe = r"""39"""
KEY_approxeq = r"""16785992"""
KEY_approximate = r"""2248"""
KEY_aring = r"""229"""
KEY_asciicircum = r"""94"""
KEY_asciitilde = r"""126"""
KEY_asterisk = r"""42"""
KEY_at = r"""64"""
KEY_atilde = r"""227"""
KEY_b = r"""98"""
KEY_babovedot = r"""16784899"""
KEY_backslash = r"""92"""
KEY_ballotcross = r"""2804"""
KEY_bar = r"""124"""
KEY_because = r"""16785973"""
KEY_blank = r"""2527"""
KEY_botintegral = r"""2213"""
KEY_botleftparens = r"""2220"""
KEY_botleftsqbracket = r"""2216"""
KEY_botleftsummation = r"""2226"""
KEY_botrightparens = r"""2222"""
KEY_botrightsqbracket = r"""2218"""
KEY_botrightsummation = r"""2230"""
KEY_bott = r"""2550"""
KEY_botvertsummationconnector = r"""2228"""
KEY_braceleft = r"""123"""
KEY_braceright = r"""125"""
KEY_bracketleft = r"""91"""
KEY_bracketright = r"""93"""
KEY_braille_blank = r"""16787456"""
KEY_braille_dot_1 = r"""65521"""
KEY_braille_dot_10 = r"""65530"""
KEY_braille_dot_2 = r"""65522"""
KEY_braille_dot_3 = r"""65523"""
KEY_braille_dot_4 = r"""65524"""
KEY_braille_dot_5 = r"""65525"""
KEY_braille_dot_6 = r"""65526"""
KEY_braille_dot_7 = r"""65527"""
KEY_braille_dot_8 = r"""65528"""
KEY_braille_dot_9 = r"""65529"""
KEY_braille_dots_1 = r"""16787457"""
KEY_braille_dots_12 = r"""16787459"""
KEY_braille_dots_123 = r"""16787463"""
KEY_braille_dots_1234 = r"""16787471"""
KEY_braille_dots_12345 = r"""16787487"""
KEY_braille_dots_123456 = r"""16787519"""
KEY_braille_dots_1234567 = r"""16787583"""
KEY_braille_dots_12345678 = r"""16787711"""
KEY_braille_dots_1234568 = r"""16787647"""
KEY_braille_dots_123457 = r"""16787551"""
KEY_braille_dots_1234578 = r"""16787679"""
KEY_braille_dots_123458 = r"""16787615"""
KEY_braille_dots_12346 = r"""16787503"""
KEY_braille_dots_123467 = r"""16787567"""
KEY_braille_dots_1234678 = r"""16787695"""
KEY_braille_dots_123468 = r"""16787631"""
KEY_braille_dots_12347 = r"""16787535"""
KEY_braille_dots_123478 = r"""16787663"""
KEY_braille_dots_12348 = r"""16787599"""
KEY_braille_dots_1235 = r"""16787479"""
KEY_braille_dots_12356 = r"""16787511"""
KEY_braille_dots_123567 = r"""16787575"""
KEY_braille_dots_1235678 = r"""16787703"""
KEY_braille_dots_123568 = r"""16787639"""
KEY_braille_dots_12357 = r"""16787543"""
KEY_braille_dots_123578 = r"""16787671"""
KEY_braille_dots_12358 = r"""16787607"""
KEY_braille_dots_1236 = r"""16787495"""
KEY_braille_dots_12367 = r"""16787559"""
KEY_braille_dots_123678 = r"""16787687"""
KEY_braille_dots_12368 = r"""16787623"""
KEY_braille_dots_1237 = r"""16787527"""
KEY_braille_dots_12378 = r"""16787655"""
KEY_braille_dots_1238 = r"""16787591"""
KEY_braille_dots_124 = r"""16787467"""
KEY_braille_dots_1245 = r"""16787483"""
KEY_braille_dots_12456 = r"""16787515"""
KEY_braille_dots_124567 = r"""16787579"""
KEY_braille_dots_1245678 = r"""16787707"""
KEY_braille_dots_124568 = r"""16787643"""
KEY_braille_dots_12457 = r"""16787547"""
KEY_braille_dots_124578 = r"""16787675"""
KEY_braille_dots_12458 = r"""16787611"""
KEY_braille_dots_1246 = r"""16787499"""
KEY_braille_dots_12467 = r"""16787563"""
KEY_braille_dots_124678 = r"""16787691"""
KEY_braille_dots_12468 = r"""16787627"""
KEY_braille_dots_1247 = r"""16787531"""
KEY_braille_dots_12478 = r"""16787659"""
KEY_braille_dots_1248 = r"""16787595"""
KEY_braille_dots_125 = r"""16787475"""
KEY_braille_dots_1256 = r"""16787507"""
KEY_braille_dots_12567 = r"""16787571"""
KEY_braille_dots_125678 = r"""16787699"""
KEY_braille_dots_12568 = r"""16787635"""
KEY_braille_dots_1257 = r"""16787539"""
KEY_braille_dots_12578 = r"""16787667"""
KEY_braille_dots_1258 = r"""16787603"""
KEY_braille_dots_126 = r"""16787491"""
KEY_braille_dots_1267 = r"""16787555"""
KEY_braille_dots_12678 = r"""16787683"""
KEY_braille_dots_1268 = r"""16787619"""
KEY_braille_dots_127 = r"""16787523"""
KEY_braille_dots_1278 = r"""16787651"""
KEY_braille_dots_128 = r"""16787587"""
KEY_braille_dots_13 = r"""16787461"""
KEY_braille_dots_134 = r"""16787469"""
KEY_braille_dots_1345 = r"""16787485"""
KEY_braille_dots_13456 = r"""16787517"""
KEY_braille_dots_134567 = r"""16787581"""
KEY_braille_dots_1345678 = r"""16787709"""
KEY_braille_dots_134568 = r"""16787645"""
KEY_braille_dots_13457 = r"""16787549"""
KEY_braille_dots_134578 = r"""16787677"""
KEY_braille_dots_13458 = r"""16787613"""
KEY_braille_dots_1346 = r"""16787501"""
KEY_braille_dots_13467 = r"""16787565"""
KEY_braille_dots_134678 = r"""16787693"""
KEY_braille_dots_13468 = r"""16787629"""
KEY_braille_dots_1347 = r"""16787533"""
KEY_braille_dots_13478 = r"""16787661"""
KEY_braille_dots_1348 = r"""16787597"""
KEY_braille_dots_135 = r"""16787477"""
KEY_braille_dots_1356 = r"""16787509"""
KEY_braille_dots_13567 = r"""16787573"""
KEY_braille_dots_135678 = r"""16787701"""
KEY_braille_dots_13568 = r"""16787637"""
KEY_braille_dots_1357 = r"""16787541"""
KEY_braille_dots_13578 = r"""16787669"""
KEY_braille_dots_1358 = r"""16787605"""
KEY_braille_dots_136 = r"""16787493"""
KEY_braille_dots_1367 = r"""16787557"""
KEY_braille_dots_13678 = r"""16787685"""
KEY_braille_dots_1368 = r"""16787621"""
KEY_braille_dots_137 = r"""16787525"""
KEY_braille_dots_1378 = r"""16787653"""
KEY_braille_dots_138 = r"""16787589"""
KEY_braille_dots_14 = r"""16787465"""
KEY_braille_dots_145 = r"""16787481"""
KEY_braille_dots_1456 = r"""16787513"""
KEY_braille_dots_14567 = r"""16787577"""
KEY_braille_dots_145678 = r"""16787705"""
KEY_braille_dots_14568 = r"""16787641"""
KEY_braille_dots_1457 = r"""16787545"""
KEY_braille_dots_14578 = r"""16787673"""
KEY_braille_dots_1458 = r"""16787609"""
KEY_braille_dots_146 = r"""16787497"""
KEY_braille_dots_1467 = r"""16787561"""
KEY_braille_dots_14678 = r"""16787689"""
KEY_braille_dots_1468 = r"""16787625"""
KEY_braille_dots_147 = r"""16787529"""
KEY_braille_dots_1478 = r"""16787657"""
KEY_braille_dots_148 = r"""16787593"""
KEY_braille_dots_15 = r"""16787473"""
KEY_braille_dots_156 = r"""16787505"""
KEY_braille_dots_1567 = r"""16787569"""
KEY_braille_dots_15678 = r"""16787697"""
KEY_braille_dots_1568 = r"""16787633"""
KEY_braille_dots_157 = r"""16787537"""
KEY_braille_dots_1578 = r"""16787665"""
KEY_braille_dots_158 = r"""16787601"""
KEY_braille_dots_16 = r"""16787489"""
KEY_braille_dots_167 = r"""16787553"""
KEY_braille_dots_1678 = r"""16787681"""
KEY_braille_dots_168 = r"""16787617"""
KEY_braille_dots_17 = r"""16787521"""
KEY_braille_dots_178 = r"""16787649"""
KEY_braille_dots_18 = r"""16787585"""
KEY_braille_dots_2 = r"""16787458"""
KEY_braille_dots_23 = r"""16787462"""
KEY_braille_dots_234 = r"""16787470"""
KEY_braille_dots_2345 = r"""16787486"""
KEY_braille_dots_23456 = r"""16787518"""
KEY_braille_dots_234567 = r"""16787582"""
KEY_braille_dots_2345678 = r"""16787710"""
KEY_braille_dots_234568 = r"""16787646"""
KEY_braille_dots_23457 = r"""16787550"""
KEY_braille_dots_234578 = r"""16787678"""
KEY_braille_dots_23458 = r"""16787614"""
KEY_braille_dots_2346 = r"""16787502"""
KEY_braille_dots_23467 = r"""16787566"""
KEY_braille_dots_234678 = r"""16787694"""
KEY_braille_dots_23468 = r"""16787630"""
KEY_braille_dots_2347 = r"""16787534"""
KEY_braille_dots_23478 = r"""16787662"""
KEY_braille_dots_2348 = r"""16787598"""
KEY_braille_dots_235 = r"""16787478"""
KEY_braille_dots_2356 = r"""16787510"""
KEY_braille_dots_23567 = r"""16787574"""
KEY_braille_dots_235678 = r"""16787702"""
KEY_braille_dots_23568 = r"""16787638"""
KEY_braille_dots_2357 = r"""16787542"""
KEY_braille_dots_23578 = r"""16787670"""
KEY_braille_dots_2358 = r"""16787606"""
KEY_braille_dots_236 = r"""16787494"""
KEY_braille_dots_2367 = r"""16787558"""
KEY_braille_dots_23678 = r"""16787686"""
KEY_braille_dots_2368 = r"""16787622"""
KEY_braille_dots_237 = r"""16787526"""
KEY_braille_dots_2378 = r"""16787654"""
KEY_braille_dots_238 = r"""16787590"""
KEY_braille_dots_24 = r"""16787466"""
KEY_braille_dots_245 = r"""16787482"""
KEY_braille_dots_2456 = r"""16787514"""
KEY_braille_dots_24567 = r"""16787578"""
KEY_braille_dots_245678 = r"""16787706"""
KEY_braille_dots_24568 = r"""16787642"""
KEY_braille_dots_2457 = r"""16787546"""
KEY_braille_dots_24578 = r"""16787674"""
KEY_braille_dots_2458 = r"""16787610"""
KEY_braille_dots_246 = r"""16787498"""
KEY_braille_dots_2467 = r"""16787562"""
KEY_braille_dots_24678 = r"""16787690"""
KEY_braille_dots_2468 = r"""16787626"""
KEY_braille_dots_247 = r"""16787530"""
KEY_braille_dots_2478 = r"""16787658"""
KEY_braille_dots_248 = r"""16787594"""
KEY_braille_dots_25 = r"""16787474"""
KEY_braille_dots_256 = r"""16787506"""
KEY_braille_dots_2567 = r"""16787570"""
KEY_braille_dots_25678 = r"""16787698"""
KEY_braille_dots_2568 = r"""16787634"""
KEY_braille_dots_257 = r"""16787538"""
KEY_braille_dots_2578 = r"""16787666"""
KEY_braille_dots_258 = r"""16787602"""
KEY_braille_dots_26 = r"""16787490"""
KEY_braille_dots_267 = r"""16787554"""
KEY_braille_dots_2678 = r"""16787682"""
KEY_braille_dots_268 = r"""16787618"""
KEY_braille_dots_27 = r"""16787522"""
KEY_braille_dots_278 = r"""16787650"""
KEY_braille_dots_28 = r"""16787586"""
KEY_braille_dots_3 = r"""16787460"""
KEY_braille_dots_34 = r"""16787468"""
KEY_braille_dots_345 = r"""16787484"""
KEY_braille_dots_3456 = r"""16787516"""
KEY_braille_dots_34567 = r"""16787580"""
KEY_braille_dots_345678 = r"""16787708"""
KEY_braille_dots_34568 = r"""16787644"""
KEY_braille_dots_3457 = r"""16787548"""
KEY_braille_dots_34578 = r"""16787676"""
KEY_braille_dots_3458 = r"""16787612"""
KEY_braille_dots_346 = r"""16787500"""
KEY_braille_dots_3467 = r"""16787564"""
KEY_braille_dots_34678 = r"""16787692"""
KEY_braille_dots_3468 = r"""16787628"""
KEY_braille_dots_347 = r"""16787532"""
KEY_braille_dots_3478 = r"""16787660"""
KEY_braille_dots_348 = r"""16787596"""
KEY_braille_dots_35 = r"""16787476"""
KEY_braille_dots_356 = r"""16787508"""
KEY_braille_dots_3567 = r"""16787572"""
KEY_braille_dots_35678 = r"""16787700"""
KEY_braille_dots_3568 = r"""16787636"""
KEY_braille_dots_357 = r"""16787540"""
KEY_braille_dots_3578 = r"""16787668"""
KEY_braille_dots_358 = r"""16787604"""
KEY_braille_dots_36 = r"""16787492"""
KEY_braille_dots_367 = r"""16787556"""
KEY_braille_dots_3678 = r"""16787684"""
KEY_braille_dots_368 = r"""16787620"""
KEY_braille_dots_37 = r"""16787524"""
KEY_braille_dots_378 = r"""16787652"""
KEY_braille_dots_38 = r"""16787588"""
KEY_braille_dots_4 = r"""16787464"""
KEY_braille_dots_45 = r"""16787480"""
KEY_braille_dots_456 = r"""16787512"""
KEY_braille_dots_4567 = r"""16787576"""
KEY_braille_dots_45678 = r"""16787704"""
KEY_braille_dots_4568 = r"""16787640"""
KEY_braille_dots_457 = r"""16787544"""
KEY_braille_dots_4578 = r"""16787672"""
KEY_braille_dots_458 = r"""16787608"""
KEY_braille_dots_46 = r"""16787496"""
KEY_braille_dots_467 = r"""16787560"""
KEY_braille_dots_4678 = r"""16787688"""
KEY_braille_dots_468 = r"""16787624"""
KEY_braille_dots_47 = r"""16787528"""
KEY_braille_dots_478 = r"""16787656"""
KEY_braille_dots_48 = r"""16787592"""
KEY_braille_dots_5 = r"""16787472"""
KEY_braille_dots_56 = r"""16787504"""
KEY_braille_dots_567 = r"""16787568"""
KEY_braille_dots_5678 = r"""16787696"""
KEY_braille_dots_568 = r"""16787632"""
KEY_braille_dots_57 = r"""16787536"""
KEY_braille_dots_578 = r"""16787664"""
KEY_braille_dots_58 = r"""16787600"""
KEY_braille_dots_6 = r"""16787488"""
KEY_braille_dots_67 = r"""16787552"""
KEY_braille_dots_678 = r"""16787680"""
KEY_braille_dots_68 = r"""16787616"""
KEY_braille_dots_7 = r"""16787520"""
KEY_braille_dots_78 = r"""16787648"""
KEY_braille_dots_8 = r"""16787584"""
KEY_breve = r"""418"""
KEY_brokenbar = r"""166"""
KEY_c = r"""99"""
KEY_c_h = r"""65187"""
KEY_cabovedot = r"""741"""
KEY_cacute = r"""486"""
KEY_careof = r"""2744"""
KEY_caret = r"""2812"""
KEY_caron = r"""439"""
KEY_ccaron = r"""488"""
KEY_ccedilla = r"""231"""
KEY_ccircumflex = r"""742"""
KEY_cedilla = r"""184"""
KEY_cent = r"""162"""
KEY_ch = r"""65184"""
KEY_checkerboard = r"""2529"""
KEY_checkmark = r"""2803"""
KEY_circle = r"""3023"""
KEY_club = r"""2796"""
KEY_colon = r"""58"""
KEY_comma = r"""44"""
KEY_containsas = r"""16785931"""
KEY_copyright = r"""169"""
KEY_cr = r"""2532"""
KEY_crossinglines = r"""2542"""
KEY_cuberoot = r"""16785947"""
KEY_currency = r"""164"""
KEY_cursor = r"""2815"""
KEY_d = r"""100"""
KEY_dabovedot = r"""16784907"""
KEY_dagger = r"""2801"""
KEY_dcaron = r"""495"""
KEY_dead_A = r"""65153"""
KEY_dead_E = r"""65155"""
KEY_dead_I = r"""65157"""
KEY_dead_O = r"""65159"""
KEY_dead_U = r"""65161"""
KEY_dead_a = r"""65152"""
KEY_dead_abovecomma = r"""65124"""
KEY_dead_abovedot = r"""65110"""
KEY_dead_abovereversedcomma = r"""65125"""
KEY_dead_abovering = r"""65112"""
KEY_dead_acute = r"""65105"""
KEY_dead_belowbreve = r"""65131"""
KEY_dead_belowcircumflex = r"""65129"""
KEY_dead_belowcomma = r"""65134"""
KEY_dead_belowdiaeresis = r"""65132"""
KEY_dead_belowdot = r"""65120"""
KEY_dead_belowmacron = r"""65128"""
KEY_dead_belowring = r"""65127"""
KEY_dead_belowtilde = r"""65130"""
KEY_dead_breve = r"""65109"""
KEY_dead_capital_schwa = r"""65163"""
KEY_dead_caron = r"""65114"""
KEY_dead_cedilla = r"""65115"""
KEY_dead_circumflex = r"""65106"""
KEY_dead_currency = r"""65135"""
KEY_dead_dasia = r"""65125"""
KEY_dead_diaeresis = r"""65111"""
KEY_dead_doubleacute = r"""65113"""
KEY_dead_doublegrave = r"""65126"""
KEY_dead_e = r"""65154"""
KEY_dead_grave = r"""65104"""
KEY_dead_greek = r"""65164"""
KEY_dead_hook = r"""65121"""
KEY_dead_horn = r"""65122"""
KEY_dead_i = r"""65156"""
KEY_dead_invertedbreve = r"""65133"""
KEY_dead_iota = r"""65117"""
KEY_dead_macron = r"""65108"""
KEY_dead_o = r"""65158"""
KEY_dead_ogonek = r"""65116"""
KEY_dead_perispomeni = r"""65107"""
KEY_dead_psili = r"""65124"""
KEY_dead_semivoiced_sound = r"""65119"""
KEY_dead_small_schwa = r"""65162"""
KEY_dead_stroke = r"""65123"""
KEY_dead_tilde = r"""65107"""
KEY_dead_u = r"""65160"""
KEY_dead_voiced_sound = r"""65118"""
KEY_decimalpoint = r"""2749"""
KEY_degree = r"""176"""
KEY_diaeresis = r"""168"""
KEY_diamond = r"""2797"""
KEY_digitspace = r"""2725"""
KEY_dintegral = r"""16785964"""
KEY_division = r"""247"""
KEY_dollar = r"""36"""
KEY_doubbaselinedot = r"""2735"""
KEY_doubleacute = r"""445"""
KEY_doubledagger = r"""2802"""
KEY_doublelowquotemark = r"""2814"""
KEY_downarrow = r"""2302"""
KEY_downcaret = r"""2984"""
KEY_downshoe = r"""3030"""
KEY_downstile = r"""3012"""
KEY_downtack = r"""3010"""
KEY_dstroke = r"""496"""
KEY_e = r"""101"""
KEY_eabovedot = r"""1004"""
KEY_eacute = r"""233"""
KEY_ebelowdot = r"""16785081"""
KEY_ecaron = r"""492"""
KEY_ecircumflex = r"""234"""
KEY_ecircumflexacute = r"""16785087"""
KEY_ecircumflexbelowdot = r"""16785095"""
KEY_ecircumflexgrave = r"""16785089"""
KEY_ecircumflexhook = r"""16785091"""
KEY_ecircumflextilde = r"""16785093"""
KEY_ediaeresis = r"""235"""
KEY_egrave = r"""232"""
KEY_ehook = r"""16785083"""
KEY_eightsubscript = r"""16785544"""
KEY_eightsuperior = r"""16785528"""
KEY_elementof = r"""16785928"""
KEY_ellipsis = r"""2734"""
KEY_em3space = r"""2723"""
KEY_em4space = r"""2724"""
KEY_emacron = r"""954"""
KEY_emdash = r"""2729"""
KEY_emfilledcircle = r"""2782"""
KEY_emfilledrect = r"""2783"""
KEY_emopencircle = r"""2766"""
KEY_emopenrectangle = r"""2767"""
KEY_emptyset = r"""16785925"""
KEY_emspace = r"""2721"""
KEY_endash = r"""2730"""
KEY_enfilledcircbullet = r"""2790"""
KEY_enfilledsqbullet = r"""2791"""
KEY_eng = r"""959"""
KEY_enopencircbullet = r"""2784"""
KEY_enopensquarebullet = r"""2785"""
KEY_enspace = r"""2722"""
KEY_eogonek = r"""490"""
KEY_equal = r"""61"""
KEY_eth = r"""240"""
KEY_etilde = r"""16785085"""
KEY_exclam = r"""33"""
KEY_exclamdown = r"""161"""
KEY_ezh = r"""16777874"""
KEY_f = r"""102"""
KEY_fabovedot = r"""16784927"""
KEY_femalesymbol = r"""2808"""
KEY_ff = r"""2531"""
KEY_figdash = r"""2747"""
KEY_filledlefttribullet = r"""2780"""
KEY_filledrectbullet = r"""2779"""
KEY_filledrighttribullet = r"""2781"""
KEY_filledtribulletdown = r"""2793"""
KEY_filledtribulletup = r"""2792"""
KEY_fiveeighths = r"""2757"""
KEY_fivesixths = r"""2743"""
KEY_fivesubscript = r"""16785541"""
KEY_fivesuperior = r"""16785525"""
KEY_fourfifths = r"""2741"""
KEY_foursubscript = r"""16785540"""
KEY_foursuperior = r"""16785524"""
KEY_fourthroot = r"""16785948"""
KEY_function = r"""2294"""
KEY_g = r"""103"""
KEY_gabovedot = r"""757"""
KEY_gbreve = r"""699"""
KEY_gcaron = r"""16777703"""
KEY_gcedilla = r"""955"""
KEY_gcircumflex = r"""760"""
KEY_grave = r"""96"""
KEY_greater = r"""62"""
KEY_greaterthanequal = r"""2238"""
KEY_guillemotleft = r"""171"""
KEY_guillemotright = r"""187"""
KEY_h = r"""104"""
KEY_hairspace = r"""2728"""
KEY_hcircumflex = r"""694"""
KEY_heart = r"""2798"""
KEY_hebrew_aleph = r"""3296"""
KEY_hebrew_ayin = r"""3314"""
KEY_hebrew_bet = r"""3297"""
KEY_hebrew_beth = r"""3297"""
KEY_hebrew_chet = r"""3303"""
KEY_hebrew_dalet = r"""3299"""
KEY_hebrew_daleth = r"""3299"""
KEY_hebrew_doublelowline = r"""3295"""
KEY_hebrew_finalkaph = r"""3306"""
KEY_hebrew_finalmem = r"""3309"""
KEY_hebrew_finalnun = r"""3311"""
KEY_hebrew_finalpe = r"""3315"""
KEY_hebrew_finalzade = r"""3317"""
KEY_hebrew_finalzadi = r"""3317"""
KEY_hebrew_gimel = r"""3298"""
KEY_hebrew_gimmel = r"""3298"""
KEY_hebrew_he = r"""3300"""
KEY_hebrew_het = r"""3303"""
KEY_hebrew_kaph = r"""3307"""
KEY_hebrew_kuf = r"""3319"""
KEY_hebrew_lamed = r"""3308"""
KEY_hebrew_mem = r"""3310"""
KEY_hebrew_nun = r"""3312"""
KEY_hebrew_pe = r"""3316"""
KEY_hebrew_qoph = r"""3319"""
KEY_hebrew_resh = r"""3320"""
KEY_hebrew_samech = r"""3313"""
KEY_hebrew_samekh = r"""3313"""
KEY_hebrew_shin = r"""3321"""
KEY_hebrew_taf = r"""3322"""
KEY_hebrew_taw = r"""3322"""
KEY_hebrew_tet = r"""3304"""
KEY_hebrew_teth = r"""3304"""
KEY_hebrew_waw = r"""3301"""
KEY_hebrew_yod = r"""3305"""
KEY_hebrew_zade = r"""3318"""
KEY_hebrew_zadi = r"""3318"""
KEY_hebrew_zain = r"""3302"""
KEY_hebrew_zayin = r"""3302"""
KEY_hexagram = r"""2778"""
KEY_horizconnector = r"""2211"""
KEY_horizlinescan1 = r"""2543"""
KEY_horizlinescan3 = r"""2544"""
KEY_horizlinescan5 = r"""2545"""
KEY_horizlinescan7 = r"""2546"""
KEY_horizlinescan9 = r"""2547"""
KEY_hstroke = r"""689"""
KEY_ht = r"""2530"""
KEY_hyphen = r"""173"""
KEY_i = r"""105"""
KEY_iTouch = r"""269025120"""
KEY_iacute = r"""237"""
KEY_ibelowdot = r"""16785099"""
KEY_ibreve = r"""16777517"""
KEY_icircumflex = r"""238"""
KEY_identical = r"""2255"""
KEY_idiaeresis = r"""239"""
KEY_idotless = r"""697"""
KEY_ifonlyif = r"""2253"""
KEY_igrave = r"""236"""
KEY_ihook = r"""16785097"""
KEY_imacron = r"""1007"""
KEY_implies = r"""2254"""
KEY_includedin = r"""2266"""
KEY_includes = r"""2267"""
KEY_infinity = r"""2242"""
KEY_integral = r"""2239"""
KEY_intersection = r"""2268"""
KEY_iogonek = r"""999"""
KEY_itilde = r"""949"""
KEY_j = r"""106"""
KEY_jcircumflex = r"""700"""
KEY_jot = r"""3018"""
KEY_k = r"""107"""
KEY_kana_A = r"""1201"""
KEY_kana_CHI = r"""1217"""
KEY_kana_E = r"""1204"""
KEY_kana_FU = r"""1228"""
KEY_kana_HA = r"""1226"""
KEY_kana_HE = r"""1229"""
KEY_kana_HI = r"""1227"""
KEY_kana_HO = r"""1230"""
KEY_kana_HU = r"""1228"""
KEY_kana_I = r"""1202"""
KEY_kana_KA = r"""1206"""
KEY_kana_KE = r"""1209"""
KEY_kana_KI = r"""1207"""
KEY_kana_KO = r"""1210"""
KEY_kana_KU = r"""1208"""
KEY_kana_MA = r"""1231"""
KEY_kana_ME = r"""1234"""
KEY_kana_MI = r"""1232"""
KEY_kana_MO = r"""1235"""
KEY_kana_MU = r"""1233"""
KEY_kana_N = r"""1245"""
KEY_kana_NA = r"""1221"""
KEY_kana_NE = r"""1224"""
KEY_kana_NI = r"""1222"""
KEY_kana_NO = r"""1225"""
KEY_kana_NU = r"""1223"""
KEY_kana_O = r"""1205"""
KEY_kana_RA = r"""1239"""
KEY_kana_RE = r"""1242"""
KEY_kana_RI = r"""1240"""
KEY_kana_RO = r"""1243"""
KEY_kana_RU = r"""1241"""
KEY_kana_SA = r"""1211"""
KEY_kana_SE = r"""1214"""
KEY_kana_SHI = r"""1212"""
KEY_kana_SO = r"""1215"""
KEY_kana_SU = r"""1213"""
KEY_kana_TA = r"""1216"""
KEY_kana_TE = r"""1219"""
KEY_kana_TI = r"""1217"""
KEY_kana_TO = r"""1220"""
KEY_kana_TSU = r"""1218"""
KEY_kana_TU = r"""1218"""
KEY_kana_U = r"""1203"""
KEY_kana_WA = r"""1244"""
KEY_kana_WO = r"""1190"""
KEY_kana_YA = r"""1236"""
KEY_kana_YO = r"""1238"""
KEY_kana_YU = r"""1237"""
KEY_kana_a = r"""1191"""
KEY_kana_closingbracket = r"""1187"""
KEY_kana_comma = r"""1188"""
KEY_kana_conjunctive = r"""1189"""
KEY_kana_e = r"""1194"""
KEY_kana_fullstop = r"""1185"""
KEY_kana_i = r"""1192"""
KEY_kana_middledot = r"""1189"""
KEY_kana_o = r"""1195"""
KEY_kana_openingbracket = r"""1186"""
KEY_kana_switch = r"""65406"""
KEY_kana_tsu = r"""1199"""
KEY_kana_tu = r"""1199"""
KEY_kana_u = r"""1193"""
KEY_kana_ya = r"""1196"""
KEY_kana_yo = r"""1198"""
KEY_kana_yu = r"""1197"""
KEY_kappa = r"""930"""
KEY_kcedilla = r"""1011"""
KEY_kra = r"""930"""
KEY_l = r"""108"""
KEY_lacute = r"""485"""
KEY_latincross = r"""2777"""
KEY_lbelowdot = r"""16784951"""
KEY_lcaron = r"""437"""
KEY_lcedilla = r"""950"""
KEY_leftanglebracket = r"""2748"""
KEY_leftarrow = r"""2299"""
KEY_leftcaret = r"""2979"""
KEY_leftdoublequotemark = r"""2770"""
KEY_leftmiddlecurlybrace = r"""2223"""
KEY_leftopentriangle = r"""2764"""
KEY_leftpointer = r"""2794"""
KEY_leftradical = r"""2209"""
KEY_leftshoe = r"""3034"""
KEY_leftsinglequotemark = r"""2768"""
KEY_leftt = r"""2548"""
KEY_lefttack = r"""3036"""
KEY_less = r"""60"""
KEY_lessthanequal = r"""2236"""
KEY_lf = r"""2533"""
KEY_logicaland = r"""2270"""
KEY_logicalor = r"""2271"""
KEY_lowleftcorner = r"""2541"""
KEY_lowrightcorner = r"""2538"""
KEY_lstroke = r"""435"""
KEY_m = r"""109"""
KEY_mabovedot = r"""16784961"""
KEY_macron = r"""175"""
KEY_malesymbol = r"""2807"""
KEY_maltesecross = r"""2800"""
KEY_marker = r"""2751"""
KEY_masculine = r"""186"""
KEY_minus = r"""45"""
KEY_minutes = r"""2774"""
KEY_mu = r"""181"""
KEY_multiply = r"""215"""
KEY_musicalflat = r"""2806"""
KEY_musicalsharp = r"""2805"""
KEY_n = r"""110"""
KEY_nabla = r"""2245"""
KEY_nacute = r"""497"""
KEY_ncaron = r"""498"""
KEY_ncedilla = r"""1009"""
KEY_ninesubscript = r"""16785545"""
KEY_ninesuperior = r"""16785529"""
KEY_nl = r"""2536"""
KEY_nobreakspace = r"""160"""
KEY_notapproxeq = r"""16785991"""
KEY_notelementof = r"""16785929"""
KEY_notequal = r"""2237"""
KEY_notidentical = r"""16786018"""
KEY_notsign = r"""172"""
KEY_ntilde = r"""241"""
KEY_numbersign = r"""35"""
KEY_numerosign = r"""1712"""
KEY_o = r"""111"""
KEY_oacute = r"""243"""
KEY_obarred = r"""16777845"""
KEY_obelowdot = r"""16785101"""
KEY_ocaron = r"""16777682"""
KEY_ocircumflex = r"""244"""
KEY_ocircumflexacute = r"""16785105"""
KEY_ocircumflexbelowdot = r"""16785113"""
KEY_ocircumflexgrave = r"""16785107"""
KEY_ocircumflexhook = r"""16785109"""
KEY_ocircumflextilde = r"""16785111"""
KEY_odiaeresis = r"""246"""
KEY_odoubleacute = r"""501"""
KEY_oe = r"""5053"""
KEY_ogonek = r"""434"""
KEY_ograve = r"""242"""
KEY_ohook = r"""16785103"""
KEY_ohorn = r"""16777633"""
KEY_ohornacute = r"""16785115"""
KEY_ohornbelowdot = r"""16785123"""
KEY_ohorngrave = r"""16785117"""
KEY_ohornhook = r"""16785119"""
KEY_ohorntilde = r"""16785121"""
KEY_omacron = r"""1010"""
KEY_oneeighth = r"""2755"""
KEY_onefifth = r"""2738"""
KEY_onehalf = r"""189"""
KEY_onequarter = r"""188"""
KEY_onesixth = r"""2742"""
KEY_onesubscript = r"""16785537"""
KEY_onesuperior = r"""185"""
KEY_onethird = r"""2736"""
KEY_ooblique = r"""248"""
KEY_openrectbullet = r"""2786"""
KEY_openstar = r"""2789"""
KEY_opentribulletdown = r"""2788"""
KEY_opentribulletup = r"""2787"""
KEY_ordfeminine = r"""170"""
KEY_oslash = r"""248"""
KEY_otilde = r"""245"""
KEY_overbar = r"""3008"""
KEY_overline = r"""1150"""
KEY_p = r"""112"""
KEY_pabovedot = r"""16784983"""
KEY_paragraph = r"""182"""
KEY_parenleft = r"""40"""
KEY_parenright = r"""41"""
KEY_partdifferential = r"""16785922"""
KEY_partialderivative = r"""2287"""
KEY_percent = r"""37"""
KEY_period = r"""46"""
KEY_periodcentered = r"""183"""
KEY_permille = r"""2773"""
KEY_phonographcopyright = r"""2811"""
KEY_plus = r"""43"""
KEY_plusminus = r"""177"""
KEY_prescription = r"""2772"""
KEY_prolongedsound = r"""1200"""
KEY_punctspace = r"""2726"""
KEY_q = r"""113"""
KEY_quad = r"""3020"""
KEY_question = r"""63"""
KEY_questiondown = r"""191"""
KEY_quotedbl = r"""34"""
KEY_quoteleft = r"""96"""
KEY_quoteright = r"""39"""
KEY_r = r"""114"""
KEY_racute = r"""480"""
KEY_radical = r"""2262"""
KEY_rcaron = r"""504"""
KEY_rcedilla = r"""947"""
KEY_registered = r"""174"""
KEY_rightanglebracket = r"""2750"""
KEY_rightarrow = r"""2301"""
KEY_rightcaret = r"""2982"""
KEY_rightdoublequotemark = r"""2771"""
KEY_rightmiddlecurlybrace = r"""2224"""
KEY_rightmiddlesummation = r"""2231"""
KEY_rightopentriangle = r"""2765"""
KEY_rightpointer = r"""2795"""
KEY_rightshoe = r"""3032"""
KEY_rightsinglequotemark = r"""2769"""
KEY_rightt = r"""2549"""
KEY_righttack = r"""3068"""
KEY_s = r"""115"""
KEY_sabovedot = r"""16784993"""
KEY_sacute = r"""438"""
KEY_scaron = r"""441"""
KEY_scedilla = r"""442"""
KEY_schwa = r"""16777817"""
KEY_scircumflex = r"""766"""
KEY_script_switch = r"""65406"""
KEY_seconds = r"""2775"""
KEY_section = r"""167"""
KEY_semicolon = r"""59"""
KEY_semivoicedsound = r"""1247"""
KEY_seveneighths = r"""2758"""
KEY_sevensubscript = r"""16785543"""
KEY_sevensuperior = r"""16785527"""
KEY_signaturemark = r"""2762"""
KEY_signifblank = r"""2732"""
KEY_similarequal = r"""2249"""
KEY_singlelowquotemark = r"""2813"""
KEY_sixsubscript = r"""16785542"""
KEY_sixsuperior = r"""16785526"""
KEY_slash = r"""47"""
KEY_soliddiamond = r"""2528"""
KEY_space = r"""32"""
KEY_squareroot = r"""16785946"""
KEY_ssharp = r"""223"""
KEY_sterling = r"""163"""
KEY_stricteq = r"""16786019"""
KEY_t = r"""116"""
KEY_tabovedot = r"""16785003"""
KEY_tcaron = r"""443"""
KEY_tcedilla = r"""510"""
KEY_telephone = r"""2809"""
KEY_telephonerecorder = r"""2810"""
KEY_therefore = r"""2240"""
KEY_thinspace = r"""2727"""
KEY_thorn = r"""254"""
KEY_threeeighths = r"""2756"""
KEY_threefifths = r"""2740"""
KEY_threequarters = r"""190"""
KEY_threesubscript = r"""16785539"""
KEY_threesuperior = r"""179"""
KEY_tintegral = r"""16785965"""
KEY_topintegral = r"""2212"""
KEY_topleftparens = r"""2219"""
KEY_topleftradical = r"""2210"""
KEY_topleftsqbracket = r"""2215"""
KEY_topleftsummation = r"""2225"""
KEY_toprightparens = r"""2221"""
KEY_toprightsqbracket = r"""2217"""
KEY_toprightsummation = r"""2229"""
KEY_topt = r"""2551"""
KEY_topvertsummationconnector = r"""2227"""
KEY_trademark = r"""2761"""
KEY_trademarkincircle = r"""2763"""
KEY_tslash = r"""956"""
KEY_twofifths = r"""2739"""
KEY_twosubscript = r"""16785538"""
KEY_twosuperior = r"""178"""
KEY_twothirds = r"""2737"""
KEY_u = r"""117"""
KEY_uacute = r"""250"""
KEY_ubelowdot = r"""16785125"""
KEY_ubreve = r"""765"""
KEY_ucircumflex = r"""251"""
KEY_udiaeresis = r"""252"""
KEY_udoubleacute = r"""507"""
KEY_ugrave = r"""249"""
KEY_uhook = r"""16785127"""
KEY_uhorn = r"""16777648"""
KEY_uhornacute = r"""16785129"""
KEY_uhornbelowdot = r"""16785137"""
KEY_uhorngrave = r"""16785131"""
KEY_uhornhook = r"""16785133"""
KEY_uhorntilde = r"""16785135"""
KEY_umacron = r"""1022"""
KEY_underbar = r"""3014"""
KEY_underscore = r"""95"""
KEY_union = r"""2269"""
KEY_uogonek = r"""1017"""
KEY_uparrow = r"""2300"""
KEY_upcaret = r"""2985"""
KEY_upleftcorner = r"""2540"""
KEY_uprightcorner = r"""2539"""
KEY_upshoe = r"""3011"""
KEY_upstile = r"""3027"""
KEY_uptack = r"""3022"""
KEY_uring = r"""505"""
KEY_utilde = r"""1021"""
KEY_v = r"""118"""
KEY_variation = r"""2241"""
KEY_vertbar = r"""2552"""
KEY_vertconnector = r"""2214"""
KEY_voicedsound = r"""1246"""
KEY_vt = r"""2537"""
KEY_w = r"""119"""
KEY_wacute = r"""16785027"""
KEY_wcircumflex = r"""16777589"""
KEY_wdiaeresis = r"""16785029"""
KEY_wgrave = r"""16785025"""
KEY_x = r"""120"""
KEY_xabovedot = r"""16785035"""
KEY_y = r"""121"""
KEY_yacute = r"""253"""
KEY_ybelowdot = r"""16785141"""
KEY_ycircumflex = r"""16777591"""
KEY_ydiaeresis = r"""255"""
KEY_yen = r"""165"""
KEY_ygrave = r"""16785139"""
KEY_yhook = r"""16785143"""
KEY_ytilde = r"""16785145"""
KEY_z = r"""122"""
KEY_zabovedot = r"""447"""
KEY_zacute = r"""444"""
KEY_zcaron = r"""446"""
KEY_zerosubscript = r"""16785536"""
KEY_zerosuperior = r"""16785520"""
KEY_zstroke = r"""16777654"""
MAX_TIMECOORD_AXES = r"""128"""


class ModifierIntent:
    """This enum is used with gdk_keymap_get_modifier_mask()
in order to determine what modifiers the
currently used windowing system backend uses for particular
purposes. For example, on X11/Windows, the Control key is used for
invoking menu shortcuts (accelerators), whereas on Apple computers
it’s the Command key (which correspond to %GDK_CONTROL_MASK and
%GDK_MOD2_MASK, respectively)."""
    PRIMARY_ACCELERATOR = 0
    CONTEXT_MENU = 1
    EXTEND_SELECTION = 2
    MODIFY_SELECTION = 3
    NO_TEXT_INPUT = 4
    SHIFT_GROUP = 5
    DEFAULT_MOD_MASK = 6


class ModifierType:
    """A set of bit-flags to indicate the state of modifier keys and mouse buttons
in various event types. Typical modifier keys are Shift, Control, Meta,
Super, Hyper, Alt, Compose, Apple, CapsLock or ShiftLock.

Like the X Window System, GDK supports 8 modifier keys and 5 mouse buttons.

Since 2.10, GDK recognizes which of the Meta, Super or Hyper keys are mapped
to Mod2 - Mod5, and indicates this by setting %GDK_SUPER_MASK,
%GDK_HYPER_MASK or %GDK_META_MASK in the state field of key events.

Note that GDK may add internal values to events which include
reserved values such as %GDK_MODIFIER_RESERVED_13_MASK.  Your code
should preserve and ignore them.  You can use %GDK_MODIFIER_MASK to
remove all reserved values.

Also note that the GDK X backend interprets button press events for button
4-7 as scroll events, so %GDK_BUTTON4_MASK and %GDK_BUTTON5_MASK will never
be set."""
    SHIFT_MASK = 1
    LOCK_MASK = 2
    CONTROL_MASK = 4
    MOD1_MASK = 8
    MOD2_MASK = 16
    MOD3_MASK = 32
    MOD4_MASK = 64
    MOD5_MASK = 128
    BUTTON1_MASK = 256
    BUTTON2_MASK = 512
    BUTTON3_MASK = 1024
    BUTTON4_MASK = 2048
    BUTTON5_MASK = 4096
    MODIFIER_RESERVED_13_MASK = 8192
    MODIFIER_RESERVED_14_MASK = 16384
    MODIFIER_RESERVED_15_MASK = 32768
    MODIFIER_RESERVED_16_MASK = 65536
    MODIFIER_RESERVED_17_MASK = 131072
    MODIFIER_RESERVED_18_MASK = 262144
    MODIFIER_RESERVED_19_MASK = 524288
    MODIFIER_RESERVED_20_MASK = 1048576
    MODIFIER_RESERVED_21_MASK = 2097152
    MODIFIER_RESERVED_22_MASK = 4194304
    MODIFIER_RESERVED_23_MASK = 8388608
    MODIFIER_RESERVED_24_MASK = 16777216
    MODIFIER_RESERVED_25_MASK = 33554432
    SUPER_MASK = 67108864
    HYPER_MASK = 134217728
    META_MASK = 268435456
    MODIFIER_RESERVED_29_MASK = 536870912
    RELEASE_MASK = 1073741824
    MODIFIER_MASK = 1543512063


class NotifyType:
    """Specifies the kind of crossing for #GdkEventCrossing.

See the X11 protocol specification of LeaveNotify for
full details of crossing event generation."""
    ANCESTOR = 0
    VIRTUAL = 1
    INFERIOR = 2
    NONLINEAR = 3
    NONLINEAR_VIRTUAL = 4
    UNKNOWN = 5


class OwnerChange:
    """Specifies why a selection ownership was changed."""
    NEW_OWNER = 0
    DESTROY = 1
    CLOSE = 2
PARENT_RELATIVE = r"""1"""
PRIORITY_REDRAW = r"""20"""


class PropMode:
    """Describes how existing data is combined with new data when
using gdk_property_change()."""
    REPLACE = 0
    PREPEND = 1
    APPEND = 2


class PropertyState:
    """Specifies the type of a property change for a #GdkEventProperty."""
    NEW_VALUE = 0
    DELETE = 1


class ScrollDirection:
    """Specifies the direction for #GdkEventScroll."""
    UP = 0
    DOWN = 1
    LEFT = 2
    RIGHT = 3
    SMOOTH = 4


class SeatCapabilities:
    """Flags describing the seat capabilities."""
    NONE = 0
    POINTER = 1
    TOUCH = 2
    TABLET_STYLUS = 4
    KEYBOARD = 8
    ALL_POINTING = 7
    ALL = 15


class SettingAction:
    """Specifies the kind of modification applied to a setting in a
#GdkEventSetting."""
    NEW = 0
    CHANGED = 1
    DELETED = 2


class Status:
    """"""
    OK = 0
    ERROR = -1
    ERROR_PARAM = -2
    ERROR_FILE = -3
    ERROR_MEM = -4


class SubpixelLayout:
    """This enumeration describes how the red, green and blue components
of physical pixels on an output device are laid out."""
    UNKNOWN = 0
    NONE = 1
    HORIZONTAL_RGB = 2
    HORIZONTAL_BGR = 3
    VERTICAL_RGB = 4
    VERTICAL_BGR = 5


class TouchpadGesturePhase:
    """Specifies the current state of a touchpad gesture. All gestures are
guaranteed to begin with an event with phase %GDK_TOUCHPAD_GESTURE_PHASE_BEGIN,
followed by 0 or several events with phase %GDK_TOUCHPAD_GESTURE_PHASE_UPDATE.

A finished gesture may have 2 possible outcomes, an event with phase
%GDK_TOUCHPAD_GESTURE_PHASE_END will be emitted when the gesture is
considered successful, this should be used as the hint to perform any
permanent changes.

Cancelled gestures may be so for a variety of reasons, due to hardware
or the compositor, or due to the gesture recognition layers hinting the
gesture did not finish resolutely (eg. a 3rd finger being added during
a pinch gesture). In these cases, the last event will report the phase
%GDK_TOUCHPAD_GESTURE_PHASE_CANCEL, this should be used as a hint
to undo any visible/permanent changes that were done throughout the
progress of the gesture.

See also #GdkEventTouchpadSwipe and #GdkEventTouchpadPinch."""
    BEGIN = 0
    UPDATE = 1
    END = 2
    CANCEL = 3


class VisibilityState:
    """Specifies the visiblity status of a window for a #GdkEventVisibility."""
    UNOBSCURED = 0
    PARTIAL = 1
    FULLY_OBSCURED = 2


class VisualType:
    """A set of values that describe the manner in which the pixel values
for a visual are converted into RGB values for display."""
    STATIC_GRAY = 0
    GRAYSCALE = 1
    STATIC_COLOR = 2
    PSEUDO_COLOR = 3
    TRUE_COLOR = 4
    DIRECT_COLOR = 5


class WMDecoration:
    """These are hints originally defined by the Motif toolkit.
The window manager can use them when determining how to decorate
the window. The hint must be set before mapping the window."""
    ALL = 1
    BORDER = 2
    RESIZEH = 4
    TITLE = 8
    MENU = 16
    MINIMIZE = 32
    MAXIMIZE = 64


class WMFunction:
    """These are hints originally defined by the Motif toolkit. The window manager
can use them when determining the functions to offer for the window. The
hint must be set before mapping the window."""
    ALL = 1
    RESIZE = 2
    MOVE = 4
    MINIMIZE = 8
    MAXIMIZE = 16
    CLOSE = 32


class WindowAttributesType:
    """Used to indicate which fields in the #GdkWindowAttr struct should be honored.
For example, if you filled in the “cursor” and “x” fields of #GdkWindowAttr,
pass “@GDK_WA_X | @GDK_WA_CURSOR” to gdk_window_new(). Fields in
#GdkWindowAttr not covered by a bit in this enum are required; for example,
the @width/@height, @wclass, and @window_type fields are required, they have
no corresponding flag in #GdkWindowAttributesType."""
    TITLE = 2
    X = 4
    Y = 8
    CURSOR = 16
    VISUAL = 32
    WMCLASS = 64
    NOREDIR = 128
    TYPE_HINT = 256


class WindowEdge:
    """Determines a window edge or corner."""
    NORTH_WEST = 0
    NORTH = 1
    NORTH_EAST = 2
    WEST = 3
    EAST = 4
    SOUTH_WEST = 5
    SOUTH = 6
    SOUTH_EAST = 7


class WindowHints:
    """Used to indicate which fields of a #GdkGeometry struct should be paid
attention to. Also, the presence/absence of @GDK_HINT_POS,
@GDK_HINT_USER_POS, and @GDK_HINT_USER_SIZE is significant, though they don't
directly refer to #GdkGeometry fields. @GDK_HINT_USER_POS will be set
automatically by #GtkWindow if you call gtk_window_move().
@GDK_HINT_USER_POS and @GDK_HINT_USER_SIZE should be set if the user
specified a size/position using a --geometry command-line argument;
gtk_window_parse_geometry() automatically sets these flags."""
    POS = 1
    MIN_SIZE = 2
    MAX_SIZE = 4
    BASE_SIZE = 8
    ASPECT = 16
    RESIZE_INC = 32
    WIN_GRAVITY = 64
    USER_POS = 128
    USER_SIZE = 256


class WindowState:
    """Specifies the state of a toplevel window."""
    WITHDRAWN = 1
    ICONIFIED = 2
    MAXIMIZED = 4
    STICKY = 8
    FULLSCREEN = 16
    ABOVE = 32
    BELOW = 64
    FOCUSED = 128
    TILED = 256
    TOP_TILED = 512
    TOP_RESIZABLE = 1024
    RIGHT_TILED = 2048
    RIGHT_RESIZABLE = 4096
    BOTTOM_TILED = 8192
    BOTTOM_RESIZABLE = 16384
    LEFT_TILED = 32768
    LEFT_RESIZABLE = 65536


class WindowType:
    """Describes the kind of window."""
    ROOT = 0
    TOPLEVEL = 1
    CHILD = 2
    TEMP = 3
    FOREIGN = 4
    OFFSCREEN = 5
    SUBSURFACE = 6


class WindowTypeHint:
    """These are hints for the window manager that indicate what type of function
the window has. The window manager can use this when determining decoration
and behaviour of the window. The hint must be set before mapping the window.

See the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
specification for more details about window types."""
    NORMAL = 0
    DIALOG = 1
    MENU = 2
    TOOLBAR = 3
    SPLASHSCREEN = 4
    UTILITY = 5
    DOCK = 6
    DESKTOP = 7
    DROPDOWN_MENU = 8
    POPUP_MENU = 9
    TOOLTIP = 10
    NOTIFICATION = 11
    COMBO = 12
    DND = 13


class WindowWindowClass:
    """@GDK_INPUT_OUTPUT windows are the standard kind of window you might expect.
Such windows receive events and are also displayed on screen.
@GDK_INPUT_ONLY windows are invisible; they are usually placed above other
windows in order to trap or filter the events. You can’t draw on
@GDK_INPUT_ONLY windows."""
    INPUT_OUTPUT = 0
    INPUT_ONLY = 1

def add_option_entries_libgtk_only(group=None):
    """    Appends gdk option entries to the passed in option group. This is
    not public API and must not be used by applications.
    @param group: An option group.
    @type group: GLib.OptionGroup
    @returns: 
    @rtype: None
    """
    return object

def atom_intern(atom_name=None, only_if_exists=None):
    """    Finds or creates an atom corresponding to a given string.
    @param atom_name: a string.
    @param only_if_exists: if %TRUE, GDK is allowed to not create a new atom, but   just return %GDK_NONE if the requested atom doesn’t already   exists. Currently, the flag is ignored, since checking the   existance of an atom is as expensive as creating it.
    @type atom_name: str
    @type only_if_exists: bool
    @returns: the atom corresponding to @atom_name.
    @rtype: Atom
    """
    return object

def atom_intern_static_string(atom_name=None):
    """    Finds or creates an atom corresponding to a given string.
    
    Note that this function is identical to gdk_atom_intern() except
    that if a new #GdkAtom is created the string itself is used rather
    than a copy. This saves memory, but can only be used if the string
    will always exist. It can be used with statically
    allocated strings in the main program, but not with statically
    allocated memory in dynamically loaded modules, if you expect to
    ever unload the module again (e.g. do not use this function in
    GTK+ theme engines).
    @param atom_name: a static string
    @type atom_name: str
    @returns: the atom corresponding to @atom_name
    @rtype: Atom
    """
    return object

def beep():
    """    Emits a short beep on the default display.
    @returns: 
    @rtype: None
    """
    return object

def cairo_create(window=None):
    """    Creates a Cairo context for drawing to @window.
    
    Note that calling cairo_reset_clip() on the resulting #cairo_t will
    produce undefined results, so avoid it at all costs.
    
    Typically, this function is used to draw on a #GdkWindow out of the paint
    cycle of the toolkit; this should be avoided, as it breaks various assumptions
    and optimizations.
    
    If you are drawing on a native #GdkWindow in response to a %GDK_EXPOSE event
    you should use gdk_window_begin_draw_frame() and gdk_drawing_context_get_cairo_context()
    instead. GTK will automatically do this for you when drawing a widget.
    @param window: a #GdkWindow
    @type window: Window
    @returns: A newly created Cairo context. Free with  cairo_destroy() when you are done drawing.
    @rtype: cairo.Context
    """
    return object

def cairo_draw_from_gl(cr=None, window=None, source=None, source_type=None, buffer_scale=None, x=None, y=None, width=None, height=None):
    """    This is the main way to draw GL content in GTK+. It takes a render buffer ID
    (@source_type == #GL_RENDERBUFFER) or a texture id (@source_type == #GL_TEXTURE)
    and draws it onto @cr with an OVER operation, respecting the current clip.
    The top left corner of the rectangle specified by @x, @y, @width and @height
    will be drawn at the current (0,0) position of the cairo_t.
    
    This will work for *all* cairo_t, as long as @window is realized, but the
    fallback implementation that reads back the pixels from the buffer may be
    used in the general case. In the case of direct drawing to a window with
    no special effects applied to @cr it will however use a more efficient
    approach.
    
    For #GL_RENDERBUFFER the code will always fall back to software for buffers
    with alpha components, so make sure you use #GL_TEXTURE if using alpha.
    
    Calling this may change the current GL context.
    @param cr: a cairo context
    @param window: The window we're rendering for (not necessarily into)
    @param source: The GL ID of the source buffer
    @param source_type: The type of the @source
    @param buffer_scale: The scale-factor that the @source buffer is allocated for
    @param x: The source x position in @source to start copying from in GL coordinates
    @param y: The source y position in @source to start copying from in GL coordinates
    @param width: The width of the region to draw
    @param height: The height of the region to draw
    @type cr: cairo.Context
    @type window: Window
    @type source: int
    @type source_type: int
    @type buffer_scale: int
    @type x: int
    @type y: int
    @type width: int
    @type height: int
    @returns: 
    @rtype: None
    """
    return object

def cairo_get_clip_rectangle(cr=None, rect=None):
    """    This is a convenience function around cairo_clip_extents().
    It rounds the clip extents to integer coordinates and returns
    a boolean indicating if a clip area exists.
    @param cr: a cairo context
    @param rect: return location for the clip, or %NULL
    @type cr: cairo.Context
    @type rect: Rectangle
    @returns: %TRUE if a clip rectangle exists, %FALSE if all of @cr is
     clipped and all drawing can be skipped
    @rtype: bool
    """
    return object

def cairo_get_drawing_context(cr=None):
    """    Retrieves the #GdkDrawingContext that created the Cairo
    context @cr.
    @param cr: a Cairo context
    @type cr: cairo.Context
    @returns: a #GdkDrawingContext, if any is set
    @rtype: DrawingContext
    """
    return object

def cairo_rectangle(cr=None, rectangle=None):
    """    Adds the given rectangle to the current path of @cr.
    @param cr: a cairo context
    @param rectangle: a #GdkRectangle
    @type cr: cairo.Context
    @type rectangle: Rectangle
    @returns: 
    @rtype: None
    """
    return object

def cairo_region(cr=None, region=None):
    """    Adds the given region to the current path of @cr.
    @param cr: a cairo context
    @param region: a #cairo_region_t
    @type cr: cairo.Context
    @type region: cairo.Region
    @returns: 
    @rtype: None
    """
    return object

def cairo_region_create_from_surface(surface=None):
    """    Creates region that describes covers the area where the given
    @surface is more than 50% opaque.
    
    This function takes into account device offsets that might be
    set with cairo_surface_set_device_offset().
    @param surface: a cairo surface
    @type surface: cairo.Surface
    @returns: A #cairo_region_t; must be freed with cairo_region_destroy()
    @rtype: cairo.Region
    """
    return object

def cairo_set_source_color(cr=None, color=None):
    """    Sets the specified #GdkColor as the source color of @cr.
    @param cr: a cairo context
    @param color: a #GdkColor
    @type cr: cairo.Context
    @type color: Color
    @returns: 
    @rtype: None
    """
    return object

def cairo_set_source_pixbuf(cr=None, pixbuf=None, pixbuf_x=None, pixbuf_y=None):
    """    Sets the given pixbuf as the source pattern for @cr.
    
    The pattern has an extend mode of %CAIRO_EXTEND_NONE and is aligned
    so that the origin of @pixbuf is @pixbuf_x, @pixbuf_y.
    @param cr: a cairo context
    @param pixbuf: a #GdkPixbuf
    @param pixbuf_x: X coordinate of location to place upper left corner of @pixbuf
    @param pixbuf_y: Y coordinate of location to place upper left corner of @pixbuf
    @type cr: cairo.Context
    @type pixbuf: GdkPixbuf.Pixbuf
    @type pixbuf_x: float
    @type pixbuf_y: float
    @returns: 
    @rtype: None
    """
    return object

def cairo_set_source_rgba(cr=None, rgba=None):
    """    Sets the specified #GdkRGBA as the source color of @cr.
    @param cr: a cairo context
    @param rgba: a #GdkRGBA
    @type cr: cairo.Context
    @type rgba: RGBA
    @returns: 
    @rtype: None
    """
    return object

def cairo_set_source_window(cr=None, window=None, x=None, y=None):
    """    Sets the given window as the source pattern for @cr.
    
    The pattern has an extend mode of %CAIRO_EXTEND_NONE and is aligned
    so that the origin of @window is @x, @y. The window contains all its
    subwindows when rendering.
    
    Note that the contents of @window are undefined outside of the
    visible part of @window, so use this function with care.
    @param cr: a cairo context
    @param window: a #GdkWindow
    @param x: X coordinate of location to place upper left corner of @window
    @param y: Y coordinate of location to place upper left corner of @window
    @type cr: cairo.Context
    @type window: Window
    @type x: float
    @type y: float
    @returns: 
    @rtype: None
    """
    return object

def cairo_surface_create_from_pixbuf(pixbuf=None, scale=None, for_window=None):
    """    Creates an image surface with the same contents as
    the pixbuf.
    @param pixbuf: a #GdkPixbuf
    @param scale: the scale of the new surface, or 0 to use same as @window
    @param for_window: The window this will be drawn to, or %NULL
    @type pixbuf: GdkPixbuf.Pixbuf
    @type scale: int
    @type for_window: Window
    @returns: a new cairo surface, must be freed with cairo_surface_destroy()
    @rtype: cairo.Surface
    """
    return object

def color_parse(spec=None, color=None):
    """    Parses a textual specification of a color and fill in the
    @red, @green, and @blue fields of a #GdkColor.
    
    The string can either one of a large set of standard names
    (taken from the X11 `rgb.txt` file), or it can be a hexadecimal
    value in the form “\#rgb” “\#rrggbb”, “\#rrrgggbbb” or
    “\#rrrrggggbbbb” where “r”, “g” and “b” are hex digits of
    the red, green, and blue components of the color, respectively.
    (White in the four forms is “\#fff”, “\#ffffff”, “\#fffffffff”
    and “\#ffffffffffff”).
    @param spec: the string specifying the color
    @param color: the #GdkColor to fill in
    @type spec: str
    @type color: Color
    @returns: %TRUE if the parsing succeeded
    @rtype: bool
    """
    return object

def disable_multidevice():
    """    Disables multidevice support in GDK. This call must happen prior
    to gdk_display_open(), gtk_init(), gtk_init_with_args() or
    gtk_init_check() in order to take effect.
    
    Most common GTK+ applications won’t ever need to call this. Only
    applications that do mixed GDK/Xlib calls could want to disable
    multidevice support if such Xlib code deals with input devices in
    any way and doesn’t observe the presence of XInput 2.
    @returns: 
    @rtype: None
    """
    return object

def drag_abort(context=None, time_=None):
    """    Aborts a drag without dropping.
    
    This function is called by the drag source.
    
    This function does not need to be called in managed drag and drop
    operations. See gdk_drag_context_manage_dnd() for more information.
    @param context: a #GdkDragContext
    @param time_: the timestamp for this operation
    @type context: DragContext
    @type time_: guint32
    @returns: 
    @rtype: None
    """
    return object

def drag_begin(window=None, targets=None):
    """    Starts a drag and creates a new drag context for it.
    This function assumes that the drag is controlled by the
    client pointer device, use gdk_drag_begin_for_device() to
    begin a drag with a different device.
    
    This function is called by the drag source.
    @param window: the source window for this drag.
    @param targets: the offered targets,     as list of #GdkAtoms
    @type window: Window
    @type targets: GLib.List
    @returns: a newly created #GdkDragContext
    @rtype: DragContext
    """
    return object

def drag_begin_for_device(window=None, device=None, targets=None):
    """    Starts a drag and creates a new drag context for it.
    
    This function is called by the drag source.
    @param window: the source window for this drag
    @param device: the device that controls this drag
    @param targets: the offered targets,     as list of #GdkAtoms
    @type window: Window
    @type device: Device
    @type targets: GLib.List
    @returns: a newly created #GdkDragContext
    @rtype: DragContext
    """
    return object

def drag_begin_from_point(window=None, device=None, targets=None, x_root=None, y_root=None):
    """    Starts a drag and creates a new drag context for it.
    
    This function is called by the drag source.
    @param window: the source window for this drag
    @param device: the device that controls this drag
    @param targets: the offered targets,     as list of #GdkAtoms
    @param x_root: the x coordinate where the drag nominally started
    @param y_root: the y coordinate where the drag nominally started
    @type window: Window
    @type device: Device
    @type targets: GLib.List
    @type x_root: int
    @type y_root: int
    @returns: a newly created #GdkDragContext
    @rtype: DragContext
    """
    return object

def drag_drop(context=None, time_=None):
    """    Drops on the current destination.
    
    This function is called by the drag source.
    
    This function does not need to be called in managed drag and drop
    operations. See gdk_drag_context_manage_dnd() for more information.
    @param context: a #GdkDragContext
    @param time_: the timestamp for this operation
    @type context: DragContext
    @type time_: guint32
    @returns: 
    @rtype: None
    """
    return object

def drag_drop_done(context=None, success=None):
    """    Inform GDK if the drop ended successfully. Passing %FALSE
    for @success may trigger a drag cancellation animation.
    
    This function is called by the drag source, and should
    be the last call before dropping the reference to the
    @context.
    
    The #GdkDragContext will only take the first gdk_drag_drop_done()
    call as effective, if this function is called multiple times,
    all subsequent calls will be ignored.
    @param context: a #GdkDragContext
    @param success: whether the drag was ultimatively successful
    @type context: DragContext
    @type success: bool
    @returns: 
    @rtype: None
    """
    return object

def drag_drop_succeeded(context=None):
    """    Returns whether the dropped data has been successfully
    transferred. This function is intended to be used while
    handling a %GDK_DROP_FINISHED event, its return value is
    meaningless at other times.
    @param context: a #GdkDragContext
    @type context: DragContext
    @returns: %TRUE if the drop was successful.
    @rtype: bool
    """
    return object

def drag_find_window_for_screen(context=None, drag_window=None, screen=None, x_root=None, y_root=None, dest_window=None, protocol=None):
    """    Finds the destination window and DND protocol to use at the
    given pointer position.
    
    This function is called by the drag source to obtain the
    @dest_window and @protocol parameters for gdk_drag_motion().
    @param context: a #GdkDragContext
    @param drag_window: a window which may be at the pointer position, but     should be ignored, since it is put up by the drag source as an icon
    @param screen: the screen where the destination window is sought
    @param x_root: the x position of the pointer in root coordinates
    @param y_root: the y position of the pointer in root coordinates
    @param dest_window: location to store the destination window in
    @param protocol: location to store the DND protocol in
    @type context: DragContext
    @type drag_window: Window
    @type screen: Screen
    @type x_root: int
    @type y_root: int
    @type dest_window: Window
    @type protocol: DragProtocol
    @returns: 
    @rtype: None
    """
    return object

def drag_get_selection(context=None):
    """    Returns the selection atom for the current source window.
    @param context: a #GdkDragContext.
    @type context: DragContext
    @returns: the selection atom, or %GDK_NONE
    @rtype: Atom
    """
    return object

def drag_motion(context=None, dest_window=None, protocol=None, x_root=None, y_root=None, suggested_action=None, possible_actions=None, time_=None):
    """    Updates the drag context when the pointer moves or the
    set of actions changes.
    
    This function is called by the drag source.
    
    This function does not need to be called in managed drag and drop
    operations. See gdk_drag_context_manage_dnd() for more information.
    @param context: a #GdkDragContext
    @param dest_window: the new destination window, obtained by     gdk_drag_find_window()
    @param protocol: the DND protocol in use, obtained by gdk_drag_find_window()
    @param x_root: the x position of the pointer in root coordinates
    @param y_root: the y position of the pointer in root coordinates
    @param suggested_action: the suggested action
    @param possible_actions: the possible actions
    @param time_: the timestamp for this operation
    @type context: DragContext
    @type dest_window: Window
    @type protocol: DragProtocol
    @type x_root: int
    @type y_root: int
    @type suggested_action: DragAction
    @type possible_actions: DragAction
    @type time_: guint32
    @returns: 
    @rtype: bool
    """
    return object

def drag_status(context=None, action=None, time_=None):
    """    Selects one of the actions offered by the drag source.
    
    This function is called by the drag destination in response to
    gdk_drag_motion() called by the drag source.
    @param context: a #GdkDragContext
    @param action: the selected action which will be taken when a drop happens,    or 0 to indicate that a drop will not be accepted
    @param time_: the timestamp for this operation
    @type context: DragContext
    @type action: DragAction
    @type time_: guint32
    @returns: 
    @rtype: None
    """
    return object

def drop_finish(context=None, success=None, time_=None):
    """    Ends the drag operation after a drop.
    
    This function is called by the drag destination.
    @param context: a #GdkDragContext
    @param success: %TRUE if the data was successfully received
    @param time_: the timestamp for this operation
    @type context: DragContext
    @type success: bool
    @type time_: guint32
    @returns: 
    @rtype: None
    """
    return object

def drop_reply(context=None, accepted=None, time_=None):
    """    Accepts or rejects a drop.
    
    This function is called by the drag destination in response
    to a drop initiated by the drag source.
    @param context: a #GdkDragContext
    @param accepted: %TRUE if the drop is accepted
    @param time_: the timestamp for this operation
    @type context: DragContext
    @type accepted: bool
    @type time_: guint32
    @returns: 
    @rtype: None
    """
    return object

def error_trap_pop():
    """    Removes an error trap pushed with gdk_error_trap_push().
    May block until an error has been definitively received
    or not received from the X server. gdk_error_trap_pop_ignored()
    is preferred if you don’t need to know whether an error
    occurred, because it never has to block. If you don't
    need the return value of gdk_error_trap_pop(), use
    gdk_error_trap_pop_ignored().
    
    Prior to GDK 3.0, this function would not automatically
    sync for you, so you had to gdk_flush() if your last
    call to Xlib was not a blocking round trip.
    @returns: X error code or 0 on success
    @rtype: int
    """
    return object

def error_trap_pop_ignored():
    """    Removes an error trap pushed with gdk_error_trap_push(), but
    without bothering to wait and see whether an error occurred.  If an
    error arrives later asynchronously that was triggered while the
    trap was pushed, that error will be ignored.
    @returns: 
    @rtype: None
    """
    return object

def error_trap_push():
    """    This function allows X errors to be trapped instead of the normal
    behavior of exiting the application. It should only be used if it
    is not possible to avoid the X error in any other way. Errors are
    ignored on all #GdkDisplay currently known to the
    #GdkDisplayManager. If you don’t care which error happens and just
    want to ignore everything, pop with gdk_error_trap_pop_ignored().
    If you need the error code, use gdk_error_trap_pop() which may have
    to block and wait for the error to arrive from the X server.
    
    This API exists on all platforms but only does anything on X.
    
    You can use gdk_x11_display_error_trap_push() to ignore errors
    on only a single display.
    
    ## Trapping an X error
    
    |[<!-- language="C" -->
    gdk_error_trap_push ();
    
     // ... Call the X function which may cause an error here ...
    
    
    if (gdk_error_trap_pop ())
     {
       // ... Handle the error here ...
     }
    ]|
    @returns: 
    @rtype: None
    """
    return object

def event_get():
    """    Checks all open displays for a #GdkEvent to process,to be processed
    on, fetching events from the windowing system if necessary.
    See gdk_display_get_event().
    @returns: the next #GdkEvent to be processed, or %NULL if no events are pending. The returned #GdkEvent should be freed with gdk_event_free().
    @rtype: Event
    """
    return object

def event_handler_set(func=None, data=None, notify=None):
    """    Sets the function to call to handle all events from GDK.
    
    Note that GTK+ uses this to install its own event handler, so it is
    usually not useful for GTK+ applications. (Although an application
    can call this function then call gtk_main_do_event() to pass
    events to GTK+.)
    @param func: the function to call to handle events from GDK.
    @param data: user data to pass to the function.
    @param notify: the function to call when the handler function is removed, i.e. when          gdk_event_handler_set() is called with another event handler.
    @type func: EventFunc
    @type data: gpointer
    @type notify: GLib.DestroyNotify
    @returns: 
    @rtype: None
    """
    return object

def event_peek():
    """    If there is an event waiting in the event queue of some open
    display, returns a copy of it. See gdk_display_peek_event().
    @returns: a copy of the first #GdkEvent on some event queue, or %NULL if no events are in any queues. The returned #GdkEvent should be freed with gdk_event_free().
    @rtype: Event
    """
    return object

def event_request_motions(event=None):
    """    Request more motion notifies if @event is a motion notify hint event.
    
    This function should be used instead of gdk_window_get_pointer() to
    request further motion notifies, because it also works for extension
    events where motion notifies are provided for devices other than the
    core pointer. Coordinate extraction, processing and requesting more
    motion events from a %GDK_MOTION_NOTIFY event usually works like this:
    
    |[<!-- language="C" -->
    {
      // motion_event handler
      x = motion_event->x;
      y = motion_event->y;
      // handle (x,y) motion
      gdk_event_request_motions (motion_event); // handles is_hint events
    }
    ]|
    @param event: a valid #GdkEvent
    @type event: EventMotion
    @returns: 
    @rtype: None
    """
    return object

def events_get_angle(event1=None, event2=None, angle=None):
    """    If both events contain X/Y information, this function will return %TRUE
    and return in @angle the relative angle from @event1 to @event2. The rotation
    direction for positive angles is from the positive X axis towards the positive
    Y axis.
    @param event1: first #GdkEvent
    @param event2: second #GdkEvent
    @param angle: return location for the relative angle between both events
    @type event1: Event
    @type event2: Event
    @type angle: float
    @returns: %TRUE if the angle could be calculated.
    @rtype: bool
    """
    return object

def events_get_center(event1=None, event2=None, x=None, y=None):
    """    If both events contain X/Y information, the center of both coordinates
    will be returned in @x and @y.
    @param event1: first #GdkEvent
    @param event2: second #GdkEvent
    @param x: return location for the X coordinate of the center
    @param y: return location for the Y coordinate of the center
    @type event1: Event
    @type event2: Event
    @type x: float
    @type y: float
    @returns: %TRUE if the center could be calculated.
    @rtype: bool
    """
    return object

def events_get_distance(event1=None, event2=None, distance=None):
    """    If both events have X/Y information, the distance between both coordinates
    (as in a straight line going from @event1 to @event2) will be returned.
    @param event1: first #GdkEvent
    @param event2: second #GdkEvent
    @param distance: return location for the distance
    @type event1: Event
    @type event2: Event
    @type distance: float
    @returns: %TRUE if the distance could be calculated.
    @rtype: bool
    """
    return object

def events_pending():
    """    Checks if any events are ready to be processed for any display.
    @returns: %TRUE if any events are pending.
    @rtype: bool
    """
    return object

def flush():
    """    Flushes the output buffers of all display connections and waits
    until all requests have been processed.
    This is rarely needed by applications.
    @returns: 
    @rtype: None
    """
    return object

def get_default_root_window():
    """    Obtains the root window (parent all other windows are inside)
    for the default display and screen.
    @returns: the default root window
    @rtype: Window
    """
    return object

def get_display():
    """    Gets the name of the display, which usually comes from the
    `DISPLAY` environment variable or the
    `--display` command line option.
    @returns: the name of the display.
    @rtype: str
    """
    return object

def get_display_arg_name():
    """    Gets the display name specified in the command line arguments passed
    to gdk_init() or gdk_parse_args(), if any.
    @returns: the display name, if specified explicitly,
   otherwise %NULL this string is owned by GTK+ and must not be
   modified or freed.
    @rtype: str
    """
    return object

def get_program_class():
    """    Gets the program class. Unless the program class has explicitly
    been set with gdk_set_program_class() or with the `--class`
    commandline option, the default value is the program name (determined
    with g_get_prgname()) with the first character converted to uppercase.
    @returns: the program class.
    @rtype: str
    """
    return object

def get_show_events():
    """    Gets whether event debugging output is enabled.
    @returns: %TRUE if event debugging output is enabled.
    @rtype: bool
    """
    return object

def gl_error_quark():
    """    
    @returns: 
    @rtype: GLib.Quark
    """
    return object

def init(argc=None, argv=None):
    """    Initializes the GDK library and connects to the windowing system.
    If initialization fails, a warning message is output and the application
    terminates with a call to `exit(1)`.
    
    Any arguments used by GDK are removed from the array and @argc and @argv
    are updated accordingly.
    
    GTK+ initializes GDK in gtk_init() and so this function is not usually
    needed by GTK+ applications.
    @param argc: the number of command line arguments.
    @param argv: the array of command line arguments.
    @type argc: int
    @returns: 
    @rtype: None
    """
    return object

def init_check(argc=None, argv=None):
    """    Initializes the GDK library and connects to the windowing system,
    returning %TRUE on success.
    
    Any arguments used by GDK are removed from the array and @argc and @argv
    are updated accordingly.
    
    GTK+ initializes GDK in gtk_init() and so this function is not usually
    needed by GTK+ applications.
    @param argc: the number of command line arguments.
    @param argv: the array of command line arguments.
    @type argc: int
    @returns: %TRUE if initialization succeeded.
    @rtype: bool
    """
    return object

def keyboard_grab(window=None, owner_events=None, time_=None):
    """    Grabs the keyboard so that all events are passed to this
    application until the keyboard is ungrabbed with gdk_keyboard_ungrab().
    This overrides any previous keyboard grab by this client.
    
    If you set up anything at the time you take the grab that needs to be cleaned
    up when the grab ends, you should handle the #GdkEventGrabBroken events that
    are emitted when the grab ends unvoluntarily.
    @param window: the #GdkWindow which will own the grab (the grab window).
    @param owner_events: if %FALSE then all keyboard events are reported with respect to   @window. If %TRUE then keyboard events for this application are   reported as normal, but keyboard events outside this application   are reported with respect to @window. Both key press and key   release events are always reported, independant of the event mask   set by the application.
    @param time_: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no timestamp is   available.
    @type window: Window
    @type owner_events: bool
    @type time_: guint32
    @returns: %GDK_GRAB_SUCCESS if the grab was successful.
    @rtype: GrabStatus
    """
    return object

def keyboard_ungrab(time_=None):
    """    Ungrabs the keyboard on the default display, if it is grabbed by this
    application.
    @param time_: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no        timestamp is available.
    @type time_: guint32
    @returns: 
    @rtype: None
    """
    return object

def keyval_convert_case(symbol=None, lower=None, upper=None):
    """    Obtains the upper- and lower-case versions of the keyval @symbol.
    Examples of keyvals are #GDK_KEY_a, #GDK_KEY_Enter, #GDK_KEY_F1, etc.
    @param symbol: a keyval
    @param lower: return location for lowercase version of @symbol
    @param upper: return location for uppercase version of @symbol
    @type symbol: int
    @type lower: int
    @type upper: int
    @returns: 
    @rtype: None
    """
    return object

def keyval_from_name(keyval_name=None):
    """    Converts a key name to a key value.
    
    The names are the same as those in the
    `gdk/gdkkeysyms.h` header file
    but without the leading “GDK_KEY_”.
    @param keyval_name: a key name
    @type keyval_name: str
    @returns: the corresponding key value, or %GDK_KEY_VoidSymbol
     if the key name is not a valid key
    @rtype: int
    """
    return object

def keyval_is_lower(keyval=None):
    """    Returns %TRUE if the given key value is in lower case.
    @param keyval: a key value.
    @type keyval: int
    @returns: %TRUE if @keyval is in lower case, or if @keyval is not
   subject to case conversion.
    @rtype: bool
    """
    return object

def keyval_is_upper(keyval=None):
    """    Returns %TRUE if the given key value is in upper case.
    @param keyval: a key value.
    @type keyval: int
    @returns: %TRUE if @keyval is in upper case, or if @keyval is not subject to  case conversion.
    @rtype: bool
    """
    return object

def keyval_name(keyval=None):
    """    Converts a key value into a symbolic name.
    
    The names are the same as those in the
    `gdk/gdkkeysyms.h` header file
    but without the leading “GDK_KEY_”.
    @param keyval: a key value
    @type keyval: int
    @returns: a string containing the name
     of the key, or %NULL if @keyval is not a valid key. The string
     should not be modified.
    @rtype: str
    """
    return object

def keyval_to_lower(keyval=None):
    """    Converts a key value to lower case, if applicable.
    @param keyval: a key value.
    @type keyval: int
    @returns: the lower case form of @keyval, or @keyval itself if it is already  in lower case or it is not subject to case conversion.
    @rtype: int
    """
    return object

def keyval_to_unicode(keyval=None):
    """    Convert from a GDK key symbol to the corresponding ISO10646 (Unicode)
    character.
    @param keyval: a GDK key symbol
    @type keyval: int
    @returns: the corresponding unicode character, or 0 if there
               is no corresponding character.
    @rtype: guint32
    """
    return object

def keyval_to_upper(keyval=None):
    """    Converts a key value to upper case, if applicable.
    @param keyval: a key value.
    @type keyval: int
    @returns: the upper case form of @keyval, or @keyval itself if it is already
   in upper case or it is not subject to case conversion.
    @rtype: int
    """
    return object

def list_visuals():
    """    Lists the available visuals for the default screen.
    (See gdk_screen_list_visuals())
    A visual describes a hardware image data format.
    For example, a visual might support 24-bit color, or 8-bit color,
    and might expect pixels to be in a certain format.
    
    Call g_list_free() on the return value when you’re finished with it.
    @returns: a list of visuals; the list must be freed, but not its contents
    @rtype: GLib.List
    """
    return object

def notify_startup_complete():
    """    Indicates to the GUI environment that the application has finished
    loading. If the applications opens windows, this function is
    normally called after opening the application’s initial set of
    windows.
    
    GTK+ will call this function automatically after opening the first
    #GtkWindow unless gtk_window_set_auto_startup_notification() is called
    to disable that feature.
    @returns: 
    @rtype: None
    """
    return object

def notify_startup_complete_with_id(startup_id=None):
    """    Indicates to the GUI environment that the application has
    finished loading, using a given identifier.
    
    GTK+ will call this function automatically for #GtkWindow
    with custom startup-notification identifier unless
    gtk_window_set_auto_startup_notification() is called to
    disable that feature.
    @param startup_id: a startup-notification identifier, for which     notification process should be completed
    @type startup_id: str
    @returns: 
    @rtype: None
    """
    return object

def offscreen_window_get_embedder(window=None):
    """    Gets the window that @window is embedded in.
    @param window: a #GdkWindow
    @type window: Window
    @returns: the embedding #GdkWindow, or
     %NULL if @window is not an mbedded offscreen window
    @rtype: Window
    """
    return object

def offscreen_window_get_surface(window=None):
    """    Gets the offscreen surface that an offscreen window renders into.
    If you need to keep this around over window resizes, you need to
    add a reference to it.
    @param window: a #GdkWindow
    @type window: Window
    @returns: The offscreen surface, or
   %NULL if not offscreen
    @rtype: cairo.Surface
    """
    return object

def offscreen_window_set_embedder(window=None, embedder=None):
    """    Sets @window to be embedded in @embedder.
    
    To fully embed an offscreen window, in addition to calling this
    function, it is also necessary to handle the #GdkWindow::pick-embedded-child
    signal on the @embedder and the #GdkWindow::to-embedder and
    #GdkWindow::from-embedder signals on @window.
    @param window: a #GdkWindow
    @param embedder: the #GdkWindow that @window gets embedded in
    @type window: Window
    @type embedder: Window
    @returns: 
    @rtype: None
    """
    return object

def pango_context_get():
    """    Creates a #PangoContext for the default GDK screen.
    
    The context must be freed when you’re finished with it.
    
    When using GTK+, normally you should use gtk_widget_get_pango_context()
    instead of this function, to get the appropriate context for
    the widget you intend to render text onto.
    
    The newly created context will have the default font options (see
    #cairo_font_options_t) for the default screen; if these options
    change it will not be updated. Using gtk_widget_get_pango_context()
    is more convenient if you want to keep a context around and track
    changes to the screen’s font rendering settings.
    @returns: a new #PangoContext for the default display
    @rtype: Pango.Context
    """
    return object

def pango_context_get_for_display(display=None):
    """    Creates a #PangoContext for @display.
    
    The context must be freed when you’re finished with it.
    
    When using GTK+, normally you should use gtk_widget_get_pango_context()
    instead of this function, to get the appropriate context for
    the widget you intend to render text onto.
    
    The newly created context will have the default font options
    (see #cairo_font_options_t) for the display; if these options
    change it will not be updated. Using gtk_widget_get_pango_context()
    is more convenient if you want to keep a context around and track
    changes to the font rendering settings.
    @param display: the #GdkDisplay for which the context is to be created
    @type display: Display
    @returns: a new #PangoContext for @display
    @rtype: Pango.Context
    """
    return object

def pango_context_get_for_screen(screen=None):
    """    Creates a #PangoContext for @screen.
    
    The context must be freed when you’re finished with it.
    
    When using GTK+, normally you should use gtk_widget_get_pango_context()
    instead of this function, to get the appropriate context for
    the widget you intend to render text onto.
    
    The newly created context will have the default font options
    (see #cairo_font_options_t) for the screen; if these options
    change it will not be updated. Using gtk_widget_get_pango_context()
    is more convenient if you want to keep a context around and track
    changes to the screen’s font rendering settings.
    @param screen: the #GdkScreen for which the context is to be created.
    @type screen: Screen
    @returns: a new #PangoContext for @screen
    @rtype: Pango.Context
    """
    return object

def pango_layout_get_clip_region(layout=None, x_origin=None, y_origin=None, index_ranges=None, n_ranges=None):
    """    Obtains a clip region which contains the areas where the given ranges
    of text would be drawn. @x_origin and @y_origin are the top left point
    to center the layout. @index_ranges should contain
    ranges of bytes in the layout’s text.
    
    Note that the regions returned correspond to logical extents of the text
    ranges, not ink extents. So the drawn layout may in fact touch areas out of
    the clip region.  The clip region is mainly useful for highlightling parts
    of text, such as when text is selected.
    @param layout: a #PangoLayout
    @param x_origin: X pixel where you intend to draw the layout with this clip
    @param y_origin: Y pixel where you intend to draw the layout with this clip
    @param index_ranges: array of byte indexes into the layout, where even members of array are start indexes and odd elements are end indexes
    @param n_ranges: number of ranges in @index_ranges, i.e. half the size of @index_ranges
    @type layout: Pango.Layout
    @type x_origin: int
    @type y_origin: int
    @type index_ranges: int
    @type n_ranges: int
    @returns: a clip region containing the given ranges
    @rtype: cairo.Region
    """
    return object

def pango_layout_line_get_clip_region(line=None, x_origin=None, y_origin=None, index_ranges=None, n_ranges=None):
    """    Obtains a clip region which contains the areas where the given
    ranges of text would be drawn. @x_origin and @y_origin are the top left
    position of the layout. @index_ranges
    should contain ranges of bytes in the layout’s text. The clip
    region will include space to the left or right of the line (to the
    layout bounding box) if you have indexes above or below the indexes
    contained inside the line. This is to draw the selection all the way
    to the side of the layout. However, the clip region is in line coordinates,
    not layout coordinates.
    
    Note that the regions returned correspond to logical extents of the text
    ranges, not ink extents. So the drawn line may in fact touch areas out of
    the clip region.  The clip region is mainly useful for highlightling parts
    of text, such as when text is selected.
    @param line: a #PangoLayoutLine
    @param x_origin: X pixel where you intend to draw the layout line with this clip
    @param y_origin: baseline pixel where you intend to draw the layout line with this clip
    @param index_ranges: array of byte indexes into the layout,     where even members of array are start indexes and odd elements     are end indexes
    @param n_ranges: number of ranges in @index_ranges, i.e. half the size of @index_ranges
    @type line: Pango.LayoutLine
    @type x_origin: int
    @type y_origin: int
    @type n_ranges: int
    @returns: a clip region containing the given ranges
    @rtype: cairo.Region
    """
    return object

def parse_args(argc=None, argv=None):
    """    Parse command line arguments, and store for future
    use by calls to gdk_display_open().
    
    Any arguments used by GDK are removed from the array and @argc and @argv are
    updated accordingly.
    
    You shouldn’t call this function explicitly if you are using
    gtk_init(), gtk_init_check(), gdk_init(), or gdk_init_check().
    @param argc: the number of command line arguments.
    @param argv: the array of command line arguments.
    @type argc: int
    @returns: 
    @rtype: None
    """
    return object

def pixbuf_get_from_surface(surface=None, src_x=None, src_y=None, width=None, height=None):
    """    Transfers image data from a #cairo_surface_t and converts it to an RGB(A)
    representation inside a #GdkPixbuf. This allows you to efficiently read
    individual pixels from cairo surfaces. For #GdkWindows, use
    gdk_pixbuf_get_from_window() instead.
    
    This function will create an RGB pixbuf with 8 bits per channel.
    The pixbuf will contain an alpha channel if the @surface contains one.
    @param surface: surface to copy from
    @param src_x: Source X coordinate within @surface
    @param src_y: Source Y coordinate within @surface
    @param width: Width in pixels of region to get
    @param height: Height in pixels of region to get
    @type surface: cairo.Surface
    @type src_x: int
    @type src_y: int
    @type width: int
    @type height: int
    @returns: A newly-created pixbuf with a
     reference count of 1, or %NULL on error
    @rtype: GdkPixbuf.Pixbuf
    """
    return object

def pixbuf_get_from_window(window=None, src_x=None, src_y=None, width=None, height=None):
    """    Transfers image data from a #GdkWindow and converts it to an RGB(A)
    representation inside a #GdkPixbuf. In other words, copies
    image data from a server-side drawable to a client-side RGB(A) buffer.
    This allows you to efficiently read individual pixels on the client side.
    
    This function will create an RGB pixbuf with 8 bits per channel with
    the size specified by the @width and @height arguments scaled by the
    scale factor of @window. The pixbuf will contain an alpha channel if
    the @window contains one.
    
    If the window is off the screen, then there is no image data in the
    obscured/offscreen regions to be placed in the pixbuf. The contents of
    portions of the pixbuf corresponding to the offscreen region are undefined.
    
    If the window you’re obtaining data from is partially obscured by
    other windows, then the contents of the pixbuf areas corresponding
    to the obscured regions are undefined.
    
    If the window is not mapped (typically because it’s iconified/minimized
    or not on the current workspace), then %NULL will be returned.
    
    If memory can’t be allocated for the return value, %NULL will be returned
    instead.
    
    (In short, there are several ways this function can fail, and if it fails
     it returns %NULL; so check the return value.)
    @param window: Source window
    @param src_x: Source X coordinate within @window
    @param src_y: Source Y coordinate within @window
    @param width: Width in pixels of region to get
    @param height: Height in pixels of region to get
    @type window: Window
    @type src_x: int
    @type src_y: int
    @type width: int
    @type height: int
    @returns: A newly-created pixbuf with a
     reference count of 1, or %NULL on error
    @rtype: GdkPixbuf.Pixbuf
    """
    return object

def pointer_grab(window=None, owner_events=None, event_mask=None, confine_to=None, cursor=None, time_=None):
    """    Grabs the pointer (usually a mouse) so that all events are passed to this
    application until the pointer is ungrabbed with gdk_pointer_ungrab(), or
    the grab window becomes unviewable.
    This overrides any previous pointer grab by this client.
    
    Pointer grabs are used for operations which need complete control over mouse
    events, even if the mouse leaves the application.
    For example in GTK+ it is used for Drag and Drop, for dragging the handle in
    the #GtkHPaned and #GtkVPaned widgets.
    
    Note that if the event mask of an X window has selected both button press and
    button release events, then a button press event will cause an automatic
    pointer grab until the button is released.
    X does this automatically since most applications expect to receive button
    press and release events in pairs.
    It is equivalent to a pointer grab on the window with @owner_events set to
    %TRUE.
    
    If you set up anything at the time you take the grab that needs to be cleaned
    up when the grab ends, you should handle the #GdkEventGrabBroken events that
    are emitted when the grab ends unvoluntarily.
    @param window: the #GdkWindow which will own the grab (the grab window).
    @param owner_events: if %FALSE then all pointer events are reported with respect to                @window and are only reported if selected by @event_mask. If %TRUE then pointer                events for this application are reported as normal, but pointer events outside                this application are reported with respect to @window and only if selected by                @event_mask. In either mode, unreported events are discarded.
    @param event_mask: specifies the event mask, which is used in accordance with              @owner_events. Note that only pointer events (i.e. button and motion events)              may be selected.
    @param confine_to: If non-%NULL, the pointer will be confined to this              window during the grab. If the pointer is outside @confine_to, it will              automatically be moved to the closest edge of @confine_to and enter              and leave events will be generated as necessary.
    @param cursor: the cursor to display while the grab is active. If this is %NULL then          the normal cursors are used for @window and its descendants, and the cursor          for @window is used for all other windows.
    @param time_: the timestamp of the event which led to this pointer grab. This usually         comes from a #GdkEventButton struct, though %GDK_CURRENT_TIME can be used if         the time isn’t known.
    @type window: Window
    @type owner_events: bool
    @type event_mask: EventMask
    @type confine_to: Window
    @type cursor: Cursor
    @type time_: guint32
    @returns: %GDK_GRAB_SUCCESS if the grab was successful.
    @rtype: GrabStatus
    """
    return object

def pointer_is_grabbed():
    """    Returns %TRUE if the pointer on the default display is currently
    grabbed by this application.
    
    Note that this does not take the inmplicit pointer grab on button
    presses into account.
    @returns: %TRUE if the pointer is currently grabbed by this application.
    @rtype: bool
    """
    return object

def pointer_ungrab(time_=None):
    """    Ungrabs the pointer on the default display, if it is grabbed by this
    application.
    @param time_: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no  timestamp is available.
    @type time_: guint32
    @returns: 
    @rtype: None
    """
    return object

def pre_parse_libgtk_only():
    """    Prepare for parsing command line arguments for GDK. This is not
    public API and should not be used in application code.
    @returns: 
    @rtype: None
    """
    return object

def property_change(window=None, property=None, type=None, format=None, mode=None, data=None, nelements=None):
    """    Changes the contents of a property on a window.
    @param window: a #GdkWindow
    @param property: the property to change
    @param type: the new type for the property. If @mode is   %GDK_PROP_MODE_PREPEND or %GDK_PROP_MODE_APPEND, then this   must match the existing type or an error will occur.
    @param format: the new format for the property. If @mode is   %GDK_PROP_MODE_PREPEND or %GDK_PROP_MODE_APPEND, then this   must match the existing format or an error will occur.
    @param mode: a value describing how the new data is to be combined   with the current data.
    @param data: the data (a `guchar *`   `gushort *`, or `gulong *`,   depending on @format), cast to a `guchar *`.
    @param nelements: the number of elements of size determined by the format,   contained in @data.
    @type window: Window
    @type property: Atom
    @type type: Atom
    @type format: int
    @type mode: PropMode
    @type data: guint8
    @type nelements: int
    @returns: 
    @rtype: None
    """
    return object

def property_delete(window=None, property=None):
    """    Deletes a property from a window.
    @param window: a #GdkWindow
    @param property: the property to delete
    @type window: Window
    @type property: Atom
    @returns: 
    @rtype: None
    """
    return object

def property_get(window=None, property=None, type=None, offset=None, length=None, pdelete=None, actual_property_type=None, actual_format=None, actual_length=None, data=None):
    """    Retrieves a portion of the contents of a property. If the
    property does not exist, then the function returns %FALSE,
    and %GDK_NONE will be stored in @actual_property_type.
    
    The XGetWindowProperty() function that gdk_property_get()
    uses has a very confusing and complicated set of semantics.
    Unfortunately, gdk_property_get() makes the situation
    worse instead of better (the semantics should be considered
    undefined), and also prints warnings to stderr in cases where it
    should return a useful error to the program. You are advised to use
    XGetWindowProperty() directly until a replacement function for
    gdk_property_get() is provided.
    @param window: a #GdkWindow
    @param property: the property to retrieve
    @param type: the desired property type, or %GDK_NONE, if any type of data   is acceptable. If this does not match the actual   type, then @actual_format and @actual_length will   be filled in, a warning will be printed to stderr   and no data will be returned.
    @param offset: the offset into the property at which to begin   retrieving data, in 4 byte units.
    @param length: the length of the data to retrieve in bytes.  Data is   considered to be retrieved in 4 byte chunks, so @length   will be rounded up to the next highest 4 byte boundary   (so be careful not to pass a value that might overflow   when rounded up).
    @param pdelete: if %TRUE, delete the property after retrieving the   data.
    @param actual_property_type: location to store the   actual type of the property.
    @param actual_format: location to store the actual return format of the   data; either 8, 16 or 32 bits.
    @param actual_length: location to store the length of the retrieved data, in   bytes.  Data returned in the 32 bit format is stored   in a long variable, so the actual number of 32 bit   elements should be be calculated via   @actual_length / sizeof(glong) to ensure portability to   64 bit systems.
    @param data: location   to store a pointer to the data. The retrieved data should be   freed with g_free() when you are finished using it.
    @type window: Window
    @type property: Atom
    @type type: Atom
    @type offset: long
    @type length: long
    @type pdelete: int
    @type actual_property_type: Atom
    @type actual_format: int
    @type actual_length: int
    @returns: %TRUE if data was successfully received and stored
   in @data, otherwise %FALSE.
    @rtype: bool
    """
    return object

def query_depths(depths=None, count=None):
    """    This function returns the available bit depths for the default
    screen. It’s equivalent to listing the visuals
    (gdk_list_visuals()) and then looking at the depth field in each
    visual, removing duplicates.
    
    The array returned by this function should not be freed.
    @param depths: return     location for available depths
    @param count: return location for number of available depths
    @type count: int
    @returns: 
    @rtype: None
    """
    return object

def query_visual_types(visual_types=None, count=None):
    """    This function returns the available visual types for the default
    screen. It’s equivalent to listing the visuals
    (gdk_list_visuals()) and then looking at the type field in each
    visual, removing duplicates.
    
    The array returned by this function should not be freed.
    @param visual_types: return     location for the available visual types
    @param count: return location for the number of available visual types
    @type count: int
    @returns: 
    @rtype: None
    """
    return object

def selection_convert(requestor=None, selection=None, target=None, time_=None):
    """    Retrieves the contents of a selection in a given
    form.
    @param requestor: a #GdkWindow.
    @param selection: an atom identifying the selection to get the   contents of.
    @param target: the form in which to retrieve the selection.
    @param time_: the timestamp to use when retrieving the   selection. The selection owner may refuse the   request if it did not own the selection at   the time indicated by the timestamp.
    @type requestor: Window
    @type selection: Atom
    @type target: Atom
    @type time_: guint32
    @returns: 
    @rtype: None
    """
    return object

def selection_owner_get(selection=None):
    """    Determines the owner of the given selection.
    @param selection: an atom indentifying a selection.
    @type selection: Atom
    @returns: if there is a selection owner
   for this window, and it is a window known to the current process,
   the #GdkWindow that owns the selection, otherwise %NULL. Note
   that the return value may be owned by a different process if a
   foreign window was previously created for that window, but a new
   foreign window will never be created by this call.
    @rtype: Window
    """
    return object

def selection_owner_get_for_display(display=None, selection=None):
    """    Determine the owner of the given selection.
    
    Note that the return value may be owned by a different
    process if a foreign window was previously created for that
    window, but a new foreign window will never be created by this call.
    @param display: a #GdkDisplay
    @param selection: an atom indentifying a selection
    @type display: Display
    @type selection: Atom
    @returns: if there is a selection owner
    for this window, and it is a window known to the current
    process, the #GdkWindow that owns the selection, otherwise
    %NULL.
    @rtype: Window
    """
    return object

def selection_owner_set(owner=None, selection=None, time_=None, send_event=None):
    """    Sets the owner of the given selection.
    @param owner: a #GdkWindow or %NULL to indicate that the   the owner for the given should be unset.
    @param selection: an atom identifying a selection.
    @param time_: timestamp to use when setting the selection.   If this is older than the timestamp given last   time the owner was set for the given selection, the   request will be ignored.
    @param send_event: if %TRUE, and the new owner is different   from the current owner, the current owner   will be sent a SelectionClear event.
    @type owner: Window
    @type selection: Atom
    @type time_: guint32
    @type send_event: bool
    @returns: %TRUE if the selection owner was successfully
   changed to @owner, otherwise %FALSE.
    @rtype: bool
    """
    return object

def selection_owner_set_for_display(display=None, owner=None, selection=None, time_=None, send_event=None):
    """    Sets the #GdkWindow @owner as the current owner of the selection @selection.
    @param display: the #GdkDisplay
    @param owner: a #GdkWindow or %NULL to indicate that the owner for         the given should be unset
    @param selection: an atom identifying a selection
    @param time_: timestamp to use when setting the selection         If this is older than the timestamp given last time the owner was         set for the given selection, the request will be ignored
    @param send_event: if %TRUE, and the new owner is different from the current              owner, the current owner will be sent a SelectionClear event
    @type display: Display
    @type owner: Window
    @type selection: Atom
    @type time_: guint32
    @type send_event: bool
    @returns: %TRUE if the selection owner was successfully changed to owner,
    otherwise %FALSE.
    @rtype: bool
    """
    return object

def selection_property_get(requestor=None, data=None, prop_type=None, prop_format=None):
    """    Retrieves selection data that was stored by the selection
    data in response to a call to gdk_selection_convert(). This function
    will not be used by applications, who should use the #GtkClipboard
    API instead.
    @param requestor: the window on which the data is stored
    @param data: location to store a pointer to the retrieved data.        If the retrieval failed, %NULL we be stored here, otherwise, it        will be non-%NULL and the returned data should be freed with g_free()        when you are finished using it. The length of the        allocated memory is one more than the length        of the returned data, and the final byte will always        be zero, to ensure nul-termination of strings
    @param prop_type: location to store the type of the property
    @param prop_format: location to store the format of the property
    @type requestor: Window
    @type data: guint8
    @type prop_type: Atom
    @type prop_format: int
    @returns: the length of the retrieved data.
    @rtype: int
    """
    return object

def selection_send_notify(requestor=None, selection=None, target=None, property=None, time_=None):
    """    Sends a response to SelectionRequest event.
    @param requestor: window to which to deliver response.
    @param selection: selection that was requested.
    @param target: target that was selected.
    @param property: property in which the selection owner stored the   data, or %GDK_NONE to indicate that the request   was rejected.
    @param time_: timestamp.
    @type requestor: Window
    @type selection: Atom
    @type target: Atom
    @type property: Atom
    @type time_: guint32
    @returns: 
    @rtype: None
    """
    return object

def selection_send_notify_for_display(display=None, requestor=None, selection=None, target=None, property=None, time_=None):
    """    Send a response to SelectionRequest event.
    @param display: the #GdkDisplay where @requestor is realized
    @param requestor: window to which to deliver response
    @param selection: selection that was requested
    @param target: target that was selected
    @param property: property in which the selection owner stored the data,            or %GDK_NONE to indicate that the request was rejected
    @param time_: timestamp
    @type display: Display
    @type requestor: Window
    @type selection: Atom
    @type target: Atom
    @type property: Atom
    @type time_: guint32
    @returns: 
    @rtype: None
    """
    return object

def set_allowed_backends(backends=None):
    """    Sets a list of backends that GDK should try to use.
    
    This can be be useful if your application does not
    work with certain GDK backends.
    
    By default, GDK tries all included backends.
    
    For example,
    |[<!-- language="C" -->
    gdk_set_allowed_backends ("wayland,quartz,*");
    ]|
    instructs GDK to try the Wayland backend first,
    followed by the Quartz backend, and then all
    others.
    
    If the `GDK_BACKEND` environment variable
    is set, it determines what backends are tried in what
    order, while still respecting the set of allowed backends
    that are specified by this function.
    
    The possible backend names are x11, win32, quartz,
    broadway, wayland. You can also include a * in the
    list to try all remaining backends.
    
    This call must happen prior to gdk_display_open(),
    gtk_init(), gtk_init_with_args() or gtk_init_check()
    in order to take effect.
    @param backends: a comma-separated list of backends
    @type backends: str
    @returns: 
    @rtype: None
    """
    return object

def set_double_click_time(msec=None):
    """    Set the double click time for the default display. See
    gdk_display_set_double_click_time().
    See also gdk_display_set_double_click_distance().
    Applications should not set this, it is a
    global user-configured setting.
    @param msec: double click time in milliseconds (thousandths of a second)
    @type msec: int
    @returns: 
    @rtype: None
    """
    return object

def set_program_class(program_class=None):
    """    Sets the program class. The X11 backend uses the program class to set
    the class name part of the `WM_CLASS` property on
    toplevel windows; see the ICCCM.
    
    The program class can still be overridden with the --class command
    line option.
    @param program_class: a string.
    @type program_class: str
    @returns: 
    @rtype: None
    """
    return object

def set_show_events(show_events=None):
    """    Sets whether a trace of received events is output.
    Note that GTK+ must be compiled with debugging (that is,
    configured using the `--enable-debug` option)
    to use this option.
    @param show_events: %TRUE to output event debugging information.
    @type show_events: bool
    @returns: 
    @rtype: None
    """
    return object

def setting_get(name=None, value=None):
    """    Obtains a desktop-wide setting, such as the double-click time,
    for the default screen. See gdk_screen_get_setting().
    @param name: the name of the setting.
    @param value: location to store the value of the setting.
    @type name: str
    @type value: GObject.Value
    @returns: %TRUE if the setting existed and a value was stored
   in @value, %FALSE otherwise.
    @rtype: bool
    """
    return object

def synthesize_window_state(window=None, unset_flags=None, set_flags=None):
    """    
    @type window: Window
    @type unset_flags: WindowState
    @type set_flags: WindowState
    @returns: 
    @rtype: None
    """
    return object

def test_render_sync(window=None):
    """    Retrieves a pixel from @window to force the windowing
    system to carry out any pending rendering commands.
    
    This function is intended to be used to synchronize with rendering
    pipelines, to benchmark windowing system rendering operations.
    @param window: a mapped #GdkWindow
    @type window: Window
    @returns: 
    @rtype: None
    """
    return object

def test_simulate_button(window=None, x=None, y=None, button=None, modifiers=None, button_pressrelease=None):
    """    This function is intended to be used in GTK+ test programs.
    It will warp the mouse pointer to the given (@x,@y) coordinates
    within @window and simulate a button press or release event.
    Because the mouse pointer needs to be warped to the target
    location, use of this function outside of test programs that
    run in their own virtual windowing system (e.g. Xvfb) is not
    recommended.
    
    Also, gdk_test_simulate_button() is a fairly low level function,
    for most testing purposes, gtk_test_widget_click() is the right
    function to call which will generate a button press event followed
    by its accompanying button release event.
    @param window: a #GdkWindow to simulate a button event for
    @param x: x coordinate within @window for the button event
    @param y: y coordinate within @window for the button event
    @param button: Number of the pointer button for the event, usually 1, 2 or 3
    @param modifiers: Keyboard modifiers the event is setup with
    @param button_pressrelease: either %GDK_BUTTON_PRESS or %GDK_BUTTON_RELEASE
    @type window: Window
    @type x: int
    @type y: int
    @type button: int
    @type modifiers: ModifierType
    @type button_pressrelease: EventType
    @returns: whether all actions necessary for a button event simulation
     were carried out successfully
    @rtype: bool
    """
    return object

def test_simulate_key(window=None, x=None, y=None, keyval=None, modifiers=None, key_pressrelease=None):
    """    This function is intended to be used in GTK+ test programs.
    If (@x,@y) are > (-1,-1), it will warp the mouse pointer to
    the given (@x,@y) coordinates within @window and simulate a
    key press or release event.
    
    When the mouse pointer is warped to the target location, use
    of this function outside of test programs that run in their
    own virtual windowing system (e.g. Xvfb) is not recommended.
    If (@x,@y) are passed as (-1,-1), the mouse pointer will not
    be warped and @window origin will be used as mouse pointer
    location for the event.
    
    Also, gdk_test_simulate_key() is a fairly low level function,
    for most testing purposes, gtk_test_widget_send_key() is the
    right function to call which will generate a key press event
    followed by its accompanying key release event.
    @param window: a #GdkWindow to simulate a key event for
    @param x: x coordinate within @window for the key event
    @param y: y coordinate within @window for the key event
    @param keyval: A GDK keyboard value
    @param modifiers: Keyboard modifiers the event is setup with
    @param key_pressrelease: either %GDK_KEY_PRESS or %GDK_KEY_RELEASE
    @type window: Window
    @type x: int
    @type y: int
    @type keyval: int
    @type modifiers: ModifierType
    @type key_pressrelease: EventType
    @returns: whether all actions necessary for a key event simulation
     were carried out successfully
    @rtype: bool
    """
    return object

def text_property_to_utf8_list_for_display(display=None, encoding=None, format=None, text=None, length=None, list=None):
    """    Converts a text property in the given encoding to
    a list of UTF-8 strings.
    @param display: a #GdkDisplay
    @param encoding: an atom representing the encoding of the text
    @param format: the format of the property
    @param text: the text to convert
    @param length: the length of @text, in bytes
    @param list: location to store the list            of strings or %NULL. The list should be freed with            g_strfreev().
    @type display: Display
    @type encoding: Atom
    @type format: int
    @type length: int
    @returns: the number of strings in the resulting list
    @rtype: int
    """
    return object

def threads_add_idle(function=None, data=None):
    """    A wrapper for the common usage of gdk_threads_add_idle_full()
    assigning the default priority, #G_PRIORITY_DEFAULT_IDLE.
    
    See gdk_threads_add_idle_full().
    @param function: function to call
    @param data: data to pass to @function
    @type function: GLib.SourceFunc
    @type data: gpointer
    @returns: the ID (greater than 0) of the event source.
    @rtype: int
    """
    return object

def threads_add_idle_full(priority=None, function=None, data=None, notify=None):
    """    Adds a function to be called whenever there are no higher priority
    events pending.  If the function returns %FALSE it is automatically
    removed from the list of event sources and will not be called again.
    
    This variant of g_idle_add_full() calls @function with the GDK lock
    held. It can be thought of a MT-safe version for GTK+ widgets for the
    following use case, where you have to worry about idle_callback()
    running in thread A and accessing @self after it has been finalized
    in thread B:
    
    |[<!-- language="C" -->
    static gboolean
    idle_callback (gpointer data)
    {
       // gdk_threads_enter(); would be needed for g_idle_add()
    
       SomeWidget *self = data;
       // do stuff with self
    
       self->idle_id = 0;
    
       // gdk_threads_leave(); would be needed for g_idle_add()
       return FALSE;
    }
    
    static void
    some_widget_do_stuff_later (SomeWidget *self)
    {
       self->idle_id = gdk_threads_add_idle (idle_callback, self)
       // using g_idle_add() here would require thread protection in the callback
    }
    
    static void
    some_widget_finalize (GObject *object)
    {
       SomeWidget *self = SOME_WIDGET (object);
       if (self->idle_id)
         g_source_remove (self->idle_id);
       G_OBJECT_CLASS (parent_class)->finalize (object);
    }
    ]|
    @param priority: the priority of the idle source. Typically this will be in the            range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE
    @param function: function to call
    @param data: data to pass to @function
    @param notify: function to call when the idle is removed, or %NULL
    @type priority: int
    @type function: GLib.SourceFunc
    @type data: gpointer
    @type notify: GLib.DestroyNotify
    @returns: the ID (greater than 0) of the event source.
    @rtype: int
    """
    return object

def threads_add_timeout(interval=None, function=None, data=None):
    """    A wrapper for the common usage of gdk_threads_add_timeout_full()
    assigning the default priority, #G_PRIORITY_DEFAULT.
    
    See gdk_threads_add_timeout_full().
    @param interval: the time between calls to the function, in milliseconds             (1/1000ths of a second)
    @param function: function to call
    @param data: data to pass to @function
    @type interval: int
    @type function: GLib.SourceFunc
    @type data: gpointer
    @returns: the ID (greater than 0) of the event source.
    @rtype: int
    """
    return object

def threads_add_timeout_full(priority=None, interval=None, function=None, data=None, notify=None):
    """    Sets a function to be called at regular intervals holding the GDK lock,
    with the given priority.  The function is called repeatedly until it
    returns %FALSE, at which point the timeout is automatically destroyed
    and the function will not be called again.  The @notify function is
    called when the timeout is destroyed.  The first call to the
    function will be at the end of the first @interval.
    
    Note that timeout functions may be delayed, due to the processing of other
    event sources. Thus they should not be relied on for precise timing.
    After each call to the timeout function, the time of the next
    timeout is recalculated based on the current time and the given interval
    (it does not try to “catch up” time lost in delays).
    
    This variant of g_timeout_add_full() can be thought of a MT-safe version
    for GTK+ widgets for the following use case:
    
    |[<!-- language="C" -->
    static gboolean timeout_callback (gpointer data)
    {
       SomeWidget *self = data;
       
       // do stuff with self
       
       self->timeout_id = 0;
       
       return G_SOURCE_REMOVE;
    }
     
    static void some_widget_do_stuff_later (SomeWidget *self)
    {
       self->timeout_id = g_timeout_add (timeout_callback, self)
    }
     
    static void some_widget_finalize (GObject *object)
    {
       SomeWidget *self = SOME_WIDGET (object);
       
       if (self->timeout_id)
         g_source_remove (self->timeout_id);
       
       G_OBJECT_CLASS (parent_class)->finalize (object);
    }
    ]|
    @param priority: the priority of the timeout source. Typically this will be in the            range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
    @param interval: the time between calls to the function, in milliseconds             (1/1000ths of a second)
    @param function: function to call
    @param data: data to pass to @function
    @param notify: function to call when the timeout is removed, or %NULL
    @type priority: int
    @type interval: int
    @type function: GLib.SourceFunc
    @type data: gpointer
    @type notify: GLib.DestroyNotify
    @returns: the ID (greater than 0) of the event source.
    @rtype: int
    """
    return object

def threads_add_timeout_seconds(interval=None, function=None, data=None):
    """    A wrapper for the common usage of gdk_threads_add_timeout_seconds_full()
    assigning the default priority, #G_PRIORITY_DEFAULT.
    
    For details, see gdk_threads_add_timeout_full().
    @param interval: the time between calls to the function, in seconds
    @param function: function to call
    @param data: data to pass to @function
    @type interval: int
    @type function: GLib.SourceFunc
    @type data: gpointer
    @returns: the ID (greater than 0) of the event source.
    @rtype: int
    """
    return object

def threads_add_timeout_seconds_full(priority=None, interval=None, function=None, data=None, notify=None):
    """    A variant of gdk_threads_add_timeout_full() with second-granularity.
    See g_timeout_add_seconds_full() for a discussion of why it is
    a good idea to use this function if you don’t need finer granularity.
    @param priority: the priority of the timeout source. Typically this will be in the            range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
    @param interval: the time between calls to the function, in seconds
    @param function: function to call
    @param data: data to pass to @function
    @param notify: function to call when the timeout is removed, or %NULL
    @type priority: int
    @type interval: int
    @type function: GLib.SourceFunc
    @type data: gpointer
    @type notify: GLib.DestroyNotify
    @returns: the ID (greater than 0) of the event source.
    @rtype: int
    """
    return object

def threads_enter():
    """    This function marks the beginning of a critical section in which
    GDK and GTK+ functions can be called safely and without causing race
    conditions. Only one thread at a time can be in such a critial
    section.
    @returns: 
    @rtype: None
    """
    return object

def threads_init():
    """    Initializes GDK so that it can be used from multiple threads
    in conjunction with gdk_threads_enter() and gdk_threads_leave().
    
    This call must be made before any use of the main loop from
    GTK+; to be safe, call it before gtk_init().
    @returns: 
    @rtype: None
    """
    return object

def threads_leave():
    """    Leaves a critical region begun with gdk_threads_enter().
    @returns: 
    @rtype: None
    """
    return object

def threads_set_lock_functions(enter_fn=None, leave_fn=None):
    """    Allows the application to replace the standard method that
    GDK uses to protect its data structures. Normally, GDK
    creates a single #GMutex that is locked by gdk_threads_enter(),
    and released by gdk_threads_leave(); using this function an
    application provides, instead, a function @enter_fn that is
    called by gdk_threads_enter() and a function @leave_fn that is
    called by gdk_threads_leave().
    
    The functions must provide at least same locking functionality
    as the default implementation, but can also do extra application
    specific processing.
    
    As an example, consider an application that has its own recursive
    lock that when held, holds the GTK+ lock as well. When GTK+ unlocks
    the GTK+ lock when entering a recursive main loop, the application
    must temporarily release its lock as well.
    
    Most threaded GTK+ apps won’t need to use this method.
    
    This method must be called before gdk_threads_init(), and cannot
    be called multiple times.
    @param enter_fn: function called to guard GDK
    @param leave_fn: function called to release the guard
    @type enter_fn: GObject.Callback
    @type leave_fn: GObject.Callback
    @returns: 
    @rtype: None
    """
    return object

def unicode_to_keyval(wc=None):
    """    Convert from a ISO10646 character to a key symbol.
    @param wc: a ISO10646 encoded character
    @type wc: guint32
    @returns: the corresponding GDK key symbol, if one exists.
               or, if there is no corresponding symbol,
               wc | 0x01000000
    @rtype: int
    """
    return object

def utf8_to_string_target(str=None):
    """    Converts an UTF-8 string into the best possible representation
    as a STRING. The representation of characters not in STRING
    is not specified; it may be as pseudo-escape sequences
    x{ABCD}, or it may be in some other form of approximation.
    @param str: a UTF-8 string
    @type str: str
    @returns: the newly-allocated string, or %NULL if the
          conversion failed. (It should not fail for any properly
          formed UTF-8 string unless system limits like memory or
          file descriptors are exceeded.)
    @rtype: str
    """
    return object


class AppLaunchContext(Gio.AppLaunchContext):
    """GdkAppLaunchContext is an implementation of #GAppLaunchContext that
handles launching an application in a graphical context. It provides
startup notification and allows to launch applications on a specific
screen or workspace.

## Launching an application

|[<!-- language="C" -->
GdkAppLaunchContext *context;

context = gdk_display_get_app_launch_context (display);

gdk_app_launch_context_set_screen (screen);
gdk_app_launch_context_set_timestamp (event->time);

if (!g_app_info_launch_default_for_uri ("http://www.gtk.org", context, &error))
  g_warning ("Launching failed: %s\n", error->message);

g_object_unref (context);
]|"""
    
    def __init__(self):
        """        Creates a new #GdkAppLaunchContext.
        @returns: Newly created AppLaunchContext
        @rtype: AppLaunchContext
        """
        return object
    @staticmethod
    def new():
        """        Creates a new #GdkAppLaunchContext.
        @returns: Newly created AppLaunchContext
        @rtype: AppLaunchContext
        """
        return object
    
    def set_desktop(self, desktop=None):
        """        Sets the workspace on which applications will be launched when
        using this context when running under a window manager that
        supports multiple workspaces, as described in the
        [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec).
        
        When the workspace is not specified or @desktop is set to -1,
        it is up to the window manager to pick one, typically it will
        be the current workspace.
        @param desktop: the number of a workspace, or -1
        @type desktop: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_display(self, display=None):
        """        Sets the display on which applications will be launched when
        using this context. See also gdk_app_launch_context_set_screen().
        @param display: a #GdkDisplay
        @type display: Display
        @returns: 
        @rtype: None
        """
        return object
    
    def set_icon(self, icon=None):
        """        Sets the icon for applications that are launched with this
        context.
        
        Window Managers can use this information when displaying startup
        notification.
        
        See also gdk_app_launch_context_set_icon_name().
        @param icon: a #GIcon, or %NULL
        @type icon: Gio.Icon
        @returns: 
        @rtype: None
        """
        return object
    
    def set_icon_name(self, icon_name=None):
        """        Sets the icon for applications that are launched with this context.
        The @icon_name will be interpreted in the same way as the Icon field
        in desktop files. See also gdk_app_launch_context_set_icon().
        
        If both @icon and @icon_name are set, the @icon_name takes priority.
        If neither @icon or @icon_name is set, the icon is taken from either
        the file that is passed to launched application or from the #GAppInfo
        for the launched application itself.
        @param icon_name: an icon name, or %NULL
        @type icon_name: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_screen(self, screen=None):
        """        Sets the screen on which applications will be launched when
        using this context. See also gdk_app_launch_context_set_display().
        
        If both @screen and @display are set, the @screen takes priority.
        If neither @screen or @display are set, the default screen and
        display are used.
        @param screen: a #GdkScreen
        @type screen: Screen
        @returns: 
        @rtype: None
        """
        return object
    
    def set_timestamp(self, timestamp=None):
        """        Sets the timestamp of @context. The timestamp should ideally
        be taken from the event that triggered the launch.
        
        Window managers can use this information to avoid moving the
        focus to the newly launched application when the user is busy
        typing in another window. This is also known as 'focus stealing
        prevention'.
        @param timestamp: a timestamp
        @type timestamp: guint32
        @returns: 
        @rtype: None
        """
        return object


class Atom():
    """An opaque type representing a string as an index into a table
of strings on the X server."""
    
    def name(self):
        """        Determines the string corresponding to an atom.
        @returns: a newly-allocated string containing the string
   corresponding to @atom. When you are done with the
   return value, you should free it using g_free().
        @rtype: str
        """
        return object
    @staticmethod
    def intern(atom_name=None, only_if_exists=None):
        """        Finds or creates an atom corresponding to a given string.
        @param atom_name: a string.
        @param only_if_exists: if %TRUE, GDK is allowed to not create a new atom, but   just return %GDK_NONE if the requested atom doesn’t already   exists. Currently, the flag is ignored, since checking the   existance of an atom is as expensive as creating it.
        @type atom_name: str
        @type only_if_exists: bool
        @returns: the atom corresponding to @atom_name.
        @rtype: Atom
        """
        return object
    @staticmethod
    def intern_static_string(atom_name=None):
        """        Finds or creates an atom corresponding to a given string.
        
        Note that this function is identical to gdk_atom_intern() except
        that if a new #GdkAtom is created the string itself is used rather
        than a copy. This saves memory, but can only be used if the string
        will always exist. It can be used with statically
        allocated strings in the main program, but not with statically
        allocated memory in dynamically loaded modules, if you expect to
        ever unload the module again (e.g. do not use this function in
        GTK+ theme engines).
        @param atom_name: a static string
        @type atom_name: str
        @returns: the atom corresponding to @atom_name
        @rtype: Atom
        """
        return object


class Color():
    """A #GdkColor is used to describe a color,
similar to the XColor struct used in the X11 drawing API."""
    
    def copy(self):
        """        Makes a copy of a #GdkColor.
        
        The result must be freed using gdk_color_free().
        @returns: a copy of @color
        @rtype: Color
        """
        return object
    
    def equal(self, colorb=None):
        """        Compares two colors.
        @param colorb: another #GdkColor
        @type colorb: Color
        @returns: %TRUE if the two colors compare equal
        @rtype: bool
        """
        return object
    
    def free(self):
        """        Frees a #GdkColor created with gdk_color_copy().
        @returns: 
        @rtype: None
        """
        return object
    
    def hash(self):
        """        A hash function suitable for using for a hash
        table that stores #GdkColors.
        @returns: The hash function applied to @color
        @rtype: int
        """
        return object
    
    def to_string(self):
        """        Returns a textual specification of @color in the hexadecimal
        form “\#rrrrggggbbbb” where “r”, “g” and “b” are hex digits
        representing the red, green and blue components respectively.
        
        The returned string can be parsed by gdk_color_parse().
        @returns: a newly-allocated text string
        @rtype: str
        """
        return object
    @staticmethod
    def parse(spec=None, color=None):
        """        Parses a textual specification of a color and fill in the
        @red, @green, and @blue fields of a #GdkColor.
        
        The string can either one of a large set of standard names
        (taken from the X11 `rgb.txt` file), or it can be a hexadecimal
        value in the form “\#rgb” “\#rrggbb”, “\#rrrgggbbb” or
        “\#rrrrggggbbbb” where “r”, “g” and “b” are hex digits of
        the red, green, and blue components of the color, respectively.
        (White in the four forms is “\#fff”, “\#ffffff”, “\#fffffffff”
        and “\#ffffffffffff”).
        @param spec: the string specifying the color
        @param color: the #GdkColor to fill in
        @type spec: str
        @type color: Color
        @returns: %TRUE if the parsing succeeded
        @rtype: bool
        """
        return object

    @property
    def pixel(self):
        return object

    @property
    def red(self):
        return object

    @property
    def green(self):
        return object

    @property
    def blue(self):
        return object


class Cursor(GObject.Object):
    """A #GdkCursor represents a cursor. Its contents are private."""
    
    def __init__(self, cursor_type=None):
        """        Creates a new cursor from the set of builtin cursors for the default display.
        See gdk_cursor_new_for_display().
        
        To make the cursor invisible, use %GDK_BLANK_CURSOR.
        @param cursor_type: cursor to create
        @type cursor_type: CursorType
        @returns: Newly created Cursor
        @rtype: Cursor
        """
        return object
    @staticmethod
    def new(cursor_type=None):
        """        Creates a new cursor from the set of builtin cursors for the default display.
        See gdk_cursor_new_for_display().
        
        To make the cursor invisible, use %GDK_BLANK_CURSOR.
        @param cursor_type: cursor to create
        @type cursor_type: CursorType
        @returns: Newly created Cursor
        @rtype: Cursor
        """
        return object
    @staticmethod
    def new_for_display(display=None, cursor_type=None):
        """        Creates a new cursor from the set of builtin cursors.
        @param display: the #GdkDisplay for which the cursor will be created
        @param cursor_type: cursor to create
        @type display: Display
        @type cursor_type: CursorType
        @returns: Newly created Cursor
        @rtype: Cursor
        """
        return object
    @staticmethod
    def new_from_name(display=None, name=None):
        """        Creates a new cursor by looking up @name in the current cursor
        theme.
        
        A recommended set of cursor names that will work across different
        platforms can be found in the CSS specification:
        - "none"
        - ![](default_cursor.png) "default"
        - ![](help_cursor.png) "help"
        - ![](pointer_cursor.png) "pointer"
        - ![](context_menu_cursor.png) "context-menu"
        - ![](progress_cursor.png) "progress"
        - ![](wait_cursor.png) "wait"
        - ![](cell_cursor.png) "cell"
        - ![](crosshair_cursor.png) "crosshair"
        - ![](text_cursor.png) "text"
        - ![](vertical_text_cursor.png) "vertical-text"
        - ![](alias_cursor.png) "alias"
        - ![](copy_cursor.png) "copy"
        - ![](no_drop_cursor.png) "no-drop"
        - ![](move_cursor.png) "move"
        - ![](not_allowed_cursor.png) "not-allowed"
        - ![](grab_cursor.png) "grab"
        - ![](grabbing_cursor.png) "grabbing"
        - ![](all_scroll_cursor.png) "all-scroll"
        - ![](col_resize_cursor.png) "col-resize"
        - ![](row_resize_cursor.png) "row-resize"
        - ![](n_resize_cursor.png) "n-resize"
        - ![](e_resize_cursor.png) "e-resize"
        - ![](s_resize_cursor.png) "s-resize"
        - ![](w_resize_cursor.png) "w-resize"
        - ![](ne_resize_cursor.png) "ne-resize"
        - ![](nw_resize_cursor.png) "nw-resize"
        - ![](sw_resize_cursor.png) "sw-resize"
        - ![](se_resize_cursor.png) "se-resize"
        - ![](ew_resize_cursor.png) "ew-resize"
        - ![](ns_resize_cursor.png) "ns-resize"
        - ![](nesw_resize_cursor.png) "nesw-resize"
        - ![](nwse_resize_cursor.png) "nwse-resize"
        - ![](zoom_in_cursor.png) "zoom-in"
        - ![](zoom_out_cursor.png) "zoom-out"
        @param display: the #GdkDisplay for which the cursor will be created
        @param name: the name of the cursor
        @type display: Display
        @type name: str
        @returns: Newly created Cursor
        @rtype: Cursor
        """
        return object
    @staticmethod
    def new_from_pixbuf(display=None, pixbuf=None, x=None, y=None):
        """        Creates a new cursor from a pixbuf.
        
        Not all GDK backends support RGBA cursors. If they are not
        supported, a monochrome approximation will be displayed.
        The functions gdk_display_supports_cursor_alpha() and
        gdk_display_supports_cursor_color() can be used to determine
        whether RGBA cursors are supported;
        gdk_display_get_default_cursor_size() and
        gdk_display_get_maximal_cursor_size() give information about
        cursor sizes.
        
        If @x or @y are `-1`, the pixbuf must have
        options named “x_hot” and “y_hot”, resp., containing
        integer values between `0` and the width resp. height of
        the pixbuf. (Since: 3.0)
        
        On the X backend, support for RGBA cursors requires a
        sufficently new version of the X Render extension.
        @param display: the #GdkDisplay for which the cursor will be created
        @param pixbuf: the #GdkPixbuf containing the cursor image
        @param x: the horizontal offset of the “hotspot” of the cursor.
        @param y: the vertical offset of the “hotspot” of the cursor.
        @type display: Display
        @type pixbuf: GdkPixbuf.Pixbuf
        @type x: int
        @type y: int
        @returns: Newly created Cursor
        @rtype: Cursor
        """
        return object
    @staticmethod
    def new_from_surface(display=None, surface=None, x=None, y=None):
        """        Creates a new cursor from a cairo image surface.
        
        Not all GDK backends support RGBA cursors. If they are not
        supported, a monochrome approximation will be displayed.
        The functions gdk_display_supports_cursor_alpha() and
        gdk_display_supports_cursor_color() can be used to determine
        whether RGBA cursors are supported;
        gdk_display_get_default_cursor_size() and
        gdk_display_get_maximal_cursor_size() give information about
        cursor sizes.
        
        On the X backend, support for RGBA cursors requires a
        sufficently new version of the X Render extension.
        @param display: the #GdkDisplay for which the cursor will be created
        @param surface: the cairo image surface containing the cursor pixel data
        @param x: the horizontal offset of the “hotspot” of the cursor
        @param y: the vertical offset of the “hotspot” of the cursor
        @type display: Display
        @type surface: cairo.Surface
        @type x: float
        @type y: float
        @returns: Newly created Cursor
        @rtype: Cursor
        """
        return object
    
    def get_cursor_type(self):
        """        Returns the cursor type for this cursor.
        @returns: a #GdkCursorType
        @rtype: CursorType
        """
        return object
    
    def get_display(self):
        """        Returns the display on which the #GdkCursor is defined.
        @returns: the #GdkDisplay associated to @cursor
        @rtype: Display
        """
        return object
    
    def get_image(self):
        """        Returns a #GdkPixbuf with the image used to display the cursor.
        
        Note that depending on the capabilities of the windowing system and
        on the cursor, GDK may not be able to obtain the image data. In this
        case, %NULL is returned.
        @returns: a #GdkPixbuf representing
   @cursor, or %NULL
        @rtype: GdkPixbuf.Pixbuf
        """
        return object
    
    def get_surface(self, x_hot=None, y_hot=None):
        """        Returns a cairo image surface with the image used to display the cursor.
        
        Note that depending on the capabilities of the windowing system and
        on the cursor, GDK may not be able to obtain the image data. In this
        case, %NULL is returned.
        @param x_hot: Location to store the hotspot x position,   or %NULL
        @param y_hot: Location to store the hotspot y position,   or %NULL
        @type x_hot: float
        @type y_hot: float
        @returns: a #cairo_surface_t
   representing @cursor, or %NULL
        @rtype: cairo.Surface
        """
        return object
    
    def ref(self):
        """        Adds a reference to @cursor.
        @returns: Same @cursor that was passed in
        @rtype: Cursor
        """
        return object
    
    def unref(self):
        """        Removes a reference from @cursor, deallocating the cursor
        if no references remain.
        @returns: 
        @rtype: None
        """
        return object


class Device(GObject.Object):
    """The #GdkDevice object represents a single input device, such
as a keyboard, a mouse, a touchpad, etc.

See the #GdkDeviceManager documentation for more information
about the various kinds of master and slave devices, and their
relationships."""
    @staticmethod
    def free_history(events=None, n_events=None):
        """        Frees an array of #GdkTimeCoord that was returned by gdk_device_get_history().
        @param events: an array of #GdkTimeCoord.
        @param n_events: the length of the array.
        @type n_events: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def grab_info_libgtk_only(display=None, device=None, grab_window=None, owner_events=None):
        """        Determines information about the current keyboard grab.
        This is not public API and must not be used by applications.
        @param display: the display for which to get the grab information
        @param device: device to get the grab information from
        @param grab_window: location to store current grab window
        @param owner_events: location to store boolean indicating whether   the @owner_events flag to gdk_keyboard_grab() or   gdk_pointer_grab() was %TRUE.
        @type display: Display
        @type device: Device
        @type grab_window: Window
        @type owner_events: bool
        @returns: %TRUE if this application currently has the  keyboard grabbed.
        @rtype: bool
        """
        return object
    
    def get_associated_device(self):
        """        Returns the associated device to @device, if @device is of type
        %GDK_DEVICE_TYPE_MASTER, it will return the paired pointer or
        keyboard.
        
        If @device is of type %GDK_DEVICE_TYPE_SLAVE, it will return
        the master device to which @device is attached to.
        
        If @device is of type %GDK_DEVICE_TYPE_FLOATING, %NULL will be
        returned, as there is no associated device.
        @returns: The associated device, or
   %NULL
        @rtype: Device
        """
        return object
    
    def get_axes(self):
        """        Returns the axes currently available on the device.
        @returns: 
        @rtype: AxisFlags
        """
        return object
    
    def get_axis(self, axes=None, use=None, value=None):
        """        Interprets an array of double as axis values for a given device,
        and locates the value in the array for a given axis use.
        @param axes: pointer to an array of axes
        @param use: the use to look for
        @param value: location to store the found value.
        @type use: AxisUse
        @type value: float
        @returns: %TRUE if the given axis use was found, otherwise %FALSE
        @rtype: bool
        """
        return object
    
    def get_axis_use(self, index_=None):
        """        Returns the axis use for @index_.
        @param index_: the index of the axis.
        @type index_: int
        @returns: a #GdkAxisUse specifying how the axis is used.
        @rtype: AxisUse
        """
        return object
    
    def get_axis_value(self, axes=None, axis_label=None, value=None):
        """        Interprets an array of double as axis values for a given device,
        and locates the value in the array for a given axis label, as returned
        by gdk_device_list_axes()
        @param axes: pointer to an array of axes
        @param axis_label: #GdkAtom with the axis label.
        @param value: location to store the found value.
        @type axis_label: Atom
        @type value: float
        @returns: %TRUE if the given axis use was found, otherwise %FALSE.
        @rtype: bool
        """
        return object
    
    def get_device_type(self):
        """        Returns the device type for @device.
        @returns: the #GdkDeviceType for @device.
        @rtype: DeviceType
        """
        return object
    
    def get_display(self):
        """        Returns the #GdkDisplay to which @device pertains.
        @returns: a #GdkDisplay. This memory is owned
          by GTK+, and must not be freed or unreffed.
        @rtype: Display
        """
        return object
    
    def get_has_cursor(self):
        """        Determines whether the pointer follows device motion.
        This is not meaningful for keyboard devices, which don't have a pointer.
        @returns: %TRUE if the pointer follows device motion
        @rtype: bool
        """
        return object
    
    def get_history(self, window=None, start=None, stop=None, events=None, n_events=None):
        """        Obtains the motion history for a pointer device; given a starting and
        ending timestamp, return all events in the motion history for
        the device in the given range of time. Some windowing systems
        do not support motion history, in which case, %FALSE will
        be returned. (This is not distinguishable from the case where
        motion history is supported and no events were found.)
        
        Note that there is also gdk_window_set_event_compression() to get
        more motion events delivered directly, independent of the windowing
        system.
        @param window: the window with respect to which which the event coordinates will be reported
        @param start: starting timestamp for range of events to return
        @param stop: ending timestamp for the range of events to return
        @param events: location to store a newly-allocated array of #GdkTimeCoord, or   %NULL
        @param n_events: location to store the length of   @events, or %NULL
        @type window: Window
        @type start: guint32
        @type stop: guint32
        @type n_events: int
        @returns: %TRUE if the windowing system supports motion history and  at least one event was found.
        @rtype: bool
        """
        return object
    
    def get_key(self, index_=None, keyval=None, modifiers=None):
        """        If @index_ has a valid keyval, this function will return %TRUE
        and fill in @keyval and @modifiers with the keyval settings.
        @param index_: the index of the macro button to get.
        @param keyval: return value for the keyval.
        @param modifiers: return value for modifiers.
        @type index_: int
        @type keyval: int
        @type modifiers: ModifierType
        @returns: %TRUE if keyval is set for @index.
        @rtype: bool
        """
        return object
    
    def get_last_event_window(self):
        """        Gets information about which window the given pointer device is in, based on events
        that have been received so far from the display server. If another application
        has a pointer grab, or this application has a grab with owner_events = %FALSE,
        %NULL may be returned even if the pointer is physically over one of this
        application's windows.
        @returns: the last window the device
        @rtype: Window
        """
        return object
    
    def get_mode(self):
        """        Determines the mode of the device.
        @returns: a #GdkInputSource
        @rtype: InputMode
        """
        return object
    
    def get_n_axes(self):
        """        Returns the number of axes the device currently has.
        @returns: the number of axes.
        @rtype: int
        """
        return object
    
    def get_n_keys(self):
        """        Returns the number of keys the device currently has.
        @returns: the number of keys.
        @rtype: int
        """
        return object
    
    def get_name(self):
        """        Determines the name of the device.
        @returns: a name
        @rtype: str
        """
        return object
    
    def get_position(self, screen=None, x=None, y=None):
        """        Gets the current location of @device. As a slave device
        coordinates are those of its master pointer, This function
        may not be called on devices of type %GDK_DEVICE_TYPE_SLAVE,
        unless there is an ongoing grab on them, see gdk_device_grab().
        @param screen: location to store the #GdkScreen          the @device is on, or %NULL.
        @param x: location to store root window X coordinate of @device, or %NULL.
        @param y: location to store root window Y coordinate of @device, or %NULL.
        @type screen: Screen
        @type x: int
        @type y: int
        @returns: 
        @rtype: None
        """
        return object
    
    def get_position_double(self, screen=None, x=None, y=None):
        """        Gets the current location of @device in double precision. As a slave device's
        coordinates are those of its master pointer, this function
        may not be called on devices of type %GDK_DEVICE_TYPE_SLAVE,
        unless there is an ongoing grab on them. See gdk_device_grab().
        @param screen: location to store the #GdkScreen          the @device is on, or %NULL.
        @param x: location to store root window X coordinate of @device, or %NULL.
        @param y: location to store root window Y coordinate of @device, or %NULL.
        @type screen: Screen
        @type x: float
        @type y: float
        @returns: 
        @rtype: None
        """
        return object
    
    def get_product_id(self):
        """        Returns the product ID of this device, or %NULL if this information couldn't
        be obtained. This ID is retrieved from the device, and is thus constant for
        it. See gdk_device_get_vendor_id() for more information.
        @returns: the product ID, or %NULL
        @rtype: str
        """
        return object
    
    def get_seat(self):
        """        Returns the #GdkSeat the device belongs to.
        @returns: A #GdkSeat. This memory is owned by GTK+ and
          must not be freed.
        @rtype: Seat
        """
        return object
    
    def get_source(self):
        """        Determines the type of the device.
        @returns: a #GdkInputSource
        @rtype: InputSource
        """
        return object
    
    def get_state(self, window=None, axes=None, mask=None):
        """        Gets the current state of a pointer device relative to @window. As a slave
        device’s coordinates are those of its master pointer, this
        function may not be called on devices of type %GDK_DEVICE_TYPE_SLAVE,
        unless there is an ongoing grab on them. See gdk_device_grab().
        @param window: a #GdkWindow.
        @param axes: an array of doubles to store the values of the axes of @device in, or %NULL.
        @param mask: location to store the modifiers, or %NULL.
        @type window: Window
        @type mask: ModifierType
        @returns: 
        @rtype: None
        """
        return object
    
    def get_vendor_id(self):
        """        Returns the vendor ID of this device, or %NULL if this information couldn't
        be obtained. This ID is retrieved from the device, and is thus constant for
        it.
        
        This function, together with gdk_device_get_product_id(), can be used to eg.
        compose #GSettings paths to store settings for this device.
        
        |[<!-- language="C" -->
         static GSettings *
         get_device_settings (GdkDevice *device)
         {
           const gchar *vendor, *product;
           GSettings *settings;
           GdkDevice *device;
           gchar *path;
        
           vendor = gdk_device_get_vendor_id (device);
           product = gdk_device_get_product_id (device);
        
           path = g_strdup_printf ("/org/example/app/devices/%s:%s/", vendor, product);
           settings = g_settings_new_with_path (DEVICE_SCHEMA, path);
           g_free (path);
        
           return settings;
         }
        ]|
        @returns: the vendor ID, or %NULL
        @rtype: str
        """
        return object
    
    def get_window_at_position(self, win_x=None, win_y=None):
        """        Obtains the window underneath @device, returning the location of the device in @win_x and @win_y. Returns
        %NULL if the window tree under @device is not known to GDK (for example, belongs to another application).
        
        As a slave device coordinates are those of its master pointer, This
        function may not be called on devices of type %GDK_DEVICE_TYPE_SLAVE,
        unless there is an ongoing grab on them, see gdk_device_grab().
        @param win_x: return location for the X coordinate of the device location,         relative to the window origin, or %NULL.
        @param win_y: return location for the Y coordinate of the device location,         relative to the window origin, or %NULL.
        @type win_x: int
        @type win_y: int
        @returns: the #GdkWindow under the device position, or %NULL.
        @rtype: Window
        """
        return object
    
    def get_window_at_position_double(self, win_x=None, win_y=None):
        """        Obtains the window underneath @device, returning the location of the device in @win_x and @win_y in
        double precision. Returns %NULL if the window tree under @device is not known to GDK (for example,
        belongs to another application).
        
        As a slave device coordinates are those of its master pointer, This
        function may not be called on devices of type %GDK_DEVICE_TYPE_SLAVE,
        unless there is an ongoing grab on them, see gdk_device_grab().
        @param win_x: return location for the X coordinate of the device location,         relative to the window origin, or %NULL.
        @param win_y: return location for the Y coordinate of the device location,         relative to the window origin, or %NULL.
        @type win_x: float
        @type win_y: float
        @returns: the #GdkWindow under the
   device position, or %NULL.
        @rtype: Window
        """
        return object
    
    def grab(self, window=None, grab_ownership=None, owner_events=None, event_mask=None, cursor=None, time_=None):
        """        Grabs the device so that all events coming from this device are passed to
        this application until the device is ungrabbed with gdk_device_ungrab(),
        or the window becomes unviewable. This overrides any previous grab on the device
        by this client.
        
        Note that @device and @window need to be on the same display.
        
        Device grabs are used for operations which need complete control over the
        given device events (either pointer or keyboard). For example in GTK+ this
        is used for Drag and Drop operations, popup menus and such.
        
        Note that if the event mask of an X window has selected both button press
        and button release events, then a button press event will cause an automatic
        pointer grab until the button is released. X does this automatically since
        most applications expect to receive button press and release events in pairs.
        It is equivalent to a pointer grab on the window with @owner_events set to
        %TRUE.
        
        If you set up anything at the time you take the grab that needs to be
        cleaned up when the grab ends, you should handle the #GdkEventGrabBroken
        events that are emitted when the grab ends unvoluntarily.
        @param window: the #GdkWindow which will own the grab (the grab window)
        @param grab_ownership: specifies the grab ownership.
        @param owner_events: if %FALSE then all device events are reported with respect to                @window and are only reported if selected by @event_mask. If                %TRUE then pointer events for this application are reported                as normal, but pointer events outside this application are                reported with respect to @window and only if selected by                @event_mask. In either mode, unreported events are discarded.
        @param event_mask: specifies the event mask, which is used in accordance with              @owner_events.
        @param cursor: the cursor to display while the grab is active if the device is          a pointer. If this is %NULL then the normal cursors are used for          @window and its descendants, and the cursor for @window is used          elsewhere.
        @param time_: the timestamp of the event which led to this pointer grab. This         usually comes from the #GdkEvent struct, though %GDK_CURRENT_TIME         can be used if the time isn’t known.
        @type window: Window
        @type grab_ownership: GrabOwnership
        @type owner_events: bool
        @type event_mask: EventMask
        @type cursor: Cursor
        @type time_: guint32
        @returns: %GDK_GRAB_SUCCESS if the grab was successful.
        @rtype: GrabStatus
        """
        return object
    
    def list_axes(self):
        """        Returns a #GList of #GdkAtoms, containing the labels for
        the axes that @device currently has.
        @returns: A #GList of #GdkAtoms, free with g_list_free().
        @rtype: GLib.List
        """
        return object
    
    def list_slave_devices(self):
        """        If the device if of type %GDK_DEVICE_TYPE_MASTER, it will return
        the list of slave devices attached to it, otherwise it will return
        %NULL
        @returns: the list of slave devices, or %NULL. The list must be
          freed with g_list_free(), the contents of the list are
          owned by GTK+ and should not be freed.
        @rtype: GLib.List
        """
        return object
    
    def set_axis_use(self, index_=None, use=None):
        """        Specifies how an axis of a device is used.
        @param index_: the index of the axis
        @param use: specifies how the axis is used
        @type index_: int
        @type use: AxisUse
        @returns: 
        @rtype: None
        """
        return object
    
    def set_key(self, index_=None, keyval=None, modifiers=None):
        """        Specifies the X key event to generate when a macro button of a device
        is pressed.
        @param index_: the index of the macro button to set
        @param keyval: the keyval to generate
        @param modifiers: the modifiers to set
        @type index_: int
        @type keyval: int
        @type modifiers: ModifierType
        @returns: 
        @rtype: None
        """
        return object
    
    def set_mode(self, mode=None):
        """        Sets a the mode of an input device. The mode controls if the
        device is active and whether the device’s range is mapped to the
        entire screen or to a single window.
        
        Note: This is only meaningful for floating devices, master devices (and
        slaves connected to these) drive the pointer cursor, which is not limited
        by the input mode.
        @param mode: the input mode.
        @type mode: InputMode
        @returns: %TRUE if the mode was successfully changed.
        @rtype: bool
        """
        return object
    
    def ungrab(self, time_=None):
        """        Release any grab on @device.
        @param time_: a timestap (e.g. %GDK_CURRENT_TIME).
        @type time_: guint32
        @returns: 
        @rtype: None
        """
        return object
    
    def warp(self, screen=None, x=None, y=None):
        """        Warps @device in @display to the point @x,@y on
        the screen @screen, unless the device is confined
        to a window by a grab, in which case it will be moved
        as far as allowed by the grab. Warping the pointer
        creates events as if the user had moved the mouse
        instantaneously to the destination.
        
        Note that the pointer should normally be under the
        control of the user. This function was added to cover
        some rare use cases like keyboard navigation support
        for the color picker in the #GtkColorSelectionDialog.
        @param screen: the screen to warp @device to.
        @param x: the X coordinate of the destination.
        @param y: the Y coordinate of the destination.
        @type screen: Screen
        @type x: int
        @type y: int
        @returns: 
        @rtype: None
        """
        return object


class DeviceManager(GObject.Object):
    """In addition to a single pointer and keyboard for user interface input,
GDK contains support for a variety of input devices, including graphics
tablets, touchscreens and multiple pointers/keyboards interacting
simultaneously with the user interface. Such input devices often have
additional features, such as sub-pixel positioning information and
additional device-dependent information.

In order to query the device hierarchy and be aware of changes in the
device hierarchy (such as virtual devices being created or removed, or
physical devices being plugged or unplugged), GDK provides
#GdkDeviceManager.

By default, and if the platform supports it, GDK is aware of multiple
keyboard/pointer pairs and multitouch devices. This behavior can be
changed by calling gdk_disable_multidevice() before gdk_display_open().
There should rarely be a need to do that though, since GDK defaults
to a compatibility mode in which it will emit just one enter/leave
event pair for all devices on a window. To enable per-device
enter/leave events and other multi-pointer interaction features,
gdk_window_set_support_multidevice() must be called on
#GdkWindows (or gtk_widget_set_support_multidevice() on widgets).
window. See the gdk_window_set_support_multidevice() documentation
for more information.

On X11, multi-device support is implemented through XInput 2.
Unless gdk_disable_multidevice() is called, the XInput 2
#GdkDeviceManager implementation will be used as the input source.
Otherwise either the core or XInput 1 implementations will be used.

For simple applications that don’t have any special interest in
input devices, the so-called “client pointer”
provides a reasonable approximation to a simple setup with a single
pointer and keyboard. The device that has been set as the client
pointer can be accessed via gdk_device_manager_get_client_pointer().

Conceptually, in multidevice mode there are 2 device types. Virtual
devices (or master devices) are represented by the pointer cursors
and keyboard foci that are seen on the screen. Physical devices (or
slave devices) represent the hardware that is controlling the virtual
devices, and thus have no visible cursor on the screen.

Virtual devices are always paired, so there is a keyboard device for every
pointer device. Associations between devices may be inspected through
gdk_device_get_associated_device().

There may be several virtual devices, and several physical devices could
be controlling each of these virtual devices. Physical devices may also
be “floating”, which means they are not attached to any virtual device.

# Master and slave devices

|[
carlos@sacarino:~$ xinput list
⎡ Virtual core pointer                          id=2    [master pointer  (3)]
⎜   ↳ Virtual core XTEST pointer                id=4    [slave  pointer  (2)]
⎜   ↳ Wacom ISDv4 E6 Pen stylus                 id=10   [slave  pointer  (2)]
⎜   ↳ Wacom ISDv4 E6 Finger touch               id=11   [slave  pointer  (2)]
⎜   ↳ SynPS/2 Synaptics TouchPad                id=13   [slave  pointer  (2)]
⎜   ↳ TPPS/2 IBM TrackPoint                     id=14   [slave  pointer  (2)]
⎜   ↳ Wacom ISDv4 E6 Pen eraser                 id=16   [slave  pointer  (2)]
⎣ Virtual core keyboard                         id=3    [master keyboard (2)]
    ↳ Virtual core XTEST keyboard               id=5    [slave  keyboard (3)]
    ↳ Power Button                              id=6    [slave  keyboard (3)]
    ↳ Video Bus                                 id=7    [slave  keyboard (3)]
    ↳ Sleep Button                              id=8    [slave  keyboard (3)]
    ↳ Integrated Camera                         id=9    [slave  keyboard (3)]
    ↳ AT Translated Set 2 keyboard              id=12   [slave  keyboard (3)]
    ↳ ThinkPad Extra Buttons                    id=15   [slave  keyboard (3)]
]|

By default, GDK will automatically listen for events coming from all
master devices, setting the #GdkDevice for all events coming from input
devices. Events containing device information are #GDK_MOTION_NOTIFY,
#GDK_BUTTON_PRESS, #GDK_2BUTTON_PRESS, #GDK_3BUTTON_PRESS,
#GDK_BUTTON_RELEASE, #GDK_SCROLL, #GDK_KEY_PRESS, #GDK_KEY_RELEASE,
#GDK_ENTER_NOTIFY, #GDK_LEAVE_NOTIFY, #GDK_FOCUS_CHANGE,
#GDK_PROXIMITY_IN, #GDK_PROXIMITY_OUT, #GDK_DRAG_ENTER, #GDK_DRAG_LEAVE,
#GDK_DRAG_MOTION, #GDK_DRAG_STATUS, #GDK_DROP_START, #GDK_DROP_FINISHED
and #GDK_GRAB_BROKEN. When dealing with an event on a master device,
it is possible to get the source (slave) device that the event originated
from via gdk_event_get_source_device().

On a standard session, all physical devices are connected by default to
the "Virtual Core Pointer/Keyboard" master devices, hence routing all events
through these. This behavior is only modified by device grabs, where the
slave device is temporarily detached for as long as the grab is held, and
more permanently by user modifications to the device hierarchy.

On certain application specific setups, it may make sense
to detach a physical device from its master pointer, and mapping it to
an specific window. This can be achieved by the combination of
gdk_device_grab() and gdk_device_set_mode().

In order to listen for events coming from devices
other than a virtual device, gdk_window_set_device_events() must be
called. Generally, this function can be used to modify the event mask
for any given device.

Input devices may also provide additional information besides X/Y.
For example, graphics tablets may also provide pressure and X/Y tilt
information. This information is device-dependent, and may be
queried through gdk_device_get_axis(). In multidevice mode, virtual
devices will change axes in order to always represent the physical
device that is routing events through it. Whenever the physical device
changes, the #GdkDevice:n-axes property will be notified, and
gdk_device_list_axes() will return the new device axes.

Devices may also have associated “keys” or
macro buttons. Such keys can be globally set to map into normal X
keyboard events. The mapping is set using gdk_device_set_key().

In GTK+ 3.20, a new #GdkSeat object has been introduced that
supersedes #GdkDeviceManager and should be preferred in newly
written code."""
    
    def get_client_pointer(self):
        """        Returns the client pointer, that is, the master pointer that acts as the core pointer
        for this application. In X11, window managers may change this depending on the interaction
        pattern under the presence of several pointers.
        
        You should use this function seldomly, only in code that isn’t triggered by a #GdkEvent
        and there aren’t other means to get a meaningful #GdkDevice to operate on.
        @returns: The client pointer. This memory is
          owned by GDK and must not be freed or unreferenced.
        @rtype: Device
        """
        return object
    
    def get_display(self):
        """        Gets the #GdkDisplay associated to @device_manager.
        @returns: the #GdkDisplay to which
          @device_manager is associated to, or %NULL. This memory is
          owned by GDK and must not be freed or unreferenced.
        @rtype: Display
        """
        return object
    
    def list_devices(self, type=None):
        """        Returns the list of devices of type @type currently attached to
        @device_manager.
        @param type: device type to get.
        @type type: DeviceType
        @returns: a list of
          #GdkDevices. The returned list must be
          freed with g_list_free (). The list elements are owned by
          GTK+ and must not be freed or unreffed.
        @rtype: GLib.List
        """
        return object


class DevicePad():
    """#GdkDevicePad is an interface implemented by devices of type
%GDK_SOURCE_TABLET_PAD, it allows querying the features provided
by the pad device.

Tablet pads may contain one or more groups, each containing a subset
of the buttons/rings/strips available. gdk_device_pad_get_n_groups()
can be used to obtain the number of groups, gdk_device_pad_get_n_features()
and gdk_device_pad_get_feature_group() can be combined to find out the
number of buttons/rings/strips the device has, and how are they grouped.

Each of those groups have different modes, which may be used to map
each individual pad feature to multiple actions. Only one mode is
effective (current) for each given group, different groups may have
different current modes. The number of available modes in a group can
be found out through gdk_device_pad_get_group_n_modes(), and the current
mode for a given group will be notified through the #GdkEventPadGroupMode
event."""
    
    def get_feature_group(self, feature=None, feature_idx=None):
        """        Returns the group the given @feature and @idx belong to,
        or -1 if feature/index do not exist in @pad.
        @param feature: the feature type to get the group from
        @param feature_idx: the index of the feature to get the group from
        @type feature: DevicePadFeature
        @type feature_idx: int
        @returns: The group number of the queried pad feature.
        @rtype: int
        """
        return object
    
    def get_group_n_modes(self, group_idx=None):
        """        Returns the number of modes that @group may have.
        @param group_idx: group to get the number of available modes from
        @type group_idx: int
        @returns: The number of modes available in @group.
        @rtype: int
        """
        return object
    
    def get_n_features(self, feature=None):
        """        Returns the number of features a tablet pad has.
        @param feature: a pad feature
        @type feature: DevicePadFeature
        @returns: The amount of elements of type @feature that this pad has.
        @rtype: int
        """
        return object
    
    def get_n_groups(self):
        """        Returns the number of groups this pad device has. Pads have
        at least one group. A pad group is a subcollection of
        buttons/strip/rings that is affected collectively by a same
        current mode.
        @returns: The number of button/ring/strip groups in the pad.
        @rtype: int
        """
        return object


class DevicePadInterface():
    """"""


class DeviceTool(GObject.Object):
    """"""
    
    def get_hardware_id(self):
        """        Gets the hardware ID of this tool, or 0 if it's not known. When
        non-zero, the identificator is unique for the given tool model,
        meaning that two identical tools will share the same @hardware_id,
        but will have different serial numbers (see gdk_device_tool_get_serial()).
        
        This is a more concrete (and device specific) method to identify
        a #GdkDeviceTool than gdk_device_tool_get_tool_type(), as a tablet
        may support multiple devices with the same #GdkDeviceToolType,
        but having different hardware identificators.
        @returns: The hardware identificator of this tool.
        @rtype: int
        """
        return object
    
    def get_serial(self):
        """        Gets the serial of this tool, this value can be used to identify a
        physical tool (eg. a tablet pen) across program executions.
        @returns: The serial ID for this tool
        @rtype: int
        """
        return object
    
    def get_tool_type(self):
        """        Gets the #GdkDeviceToolType of the tool.
        @returns: The physical type for this tool. This can be used to figure out what sort of pen is being used, such as an airbrush or a pencil.
        @rtype: DeviceToolType
        """
        return object


class Display(GObject.Object):
    """#GdkDisplay objects purpose are two fold:

- To manage and provide information about input devices (pointers and keyboards)

- To manage and provide information about the available #GdkScreens

GdkDisplay objects are the GDK representation of an X Display,
which can be described as a workstation consisting of
a keyboard, a pointing device (such as a mouse) and one or more
screens.
It is used to open and keep track of various GdkScreen objects
currently instantiated by the application. It is also used to
access the keyboard(s) and mouse pointer(s) of the display.

Most of the input device handling has been factored out into
the separate #GdkDeviceManager object. Every display has a
device manager, which you can obtain using
gdk_display_get_device_manager()."""
    @staticmethod
    def get_default():
        """        Gets the default #GdkDisplay. This is a convenience
        function for:
        `gdk_display_manager_get_default_display (gdk_display_manager_get ())`.
        @returns: a #GdkDisplay, or %NULL if
   there is no default display.
        @rtype: Display
        """
        return object
    @staticmethod
    def open(display_name=None):
        """        Opens a display.
        @param display_name: the name of the display to open
        @type display_name: str
        @returns: a #GdkDisplay, or %NULL if the
     display could not be opened
        @rtype: Display
        """
        return object
    @staticmethod
    def open_default_libgtk_only():
        """        Opens the default display specified by command line arguments or
        environment variables, sets it as the default display, and returns
        it. gdk_parse_args() must have been called first. If the default
        display has previously been set, simply returns that. An internal
        function that should not be used by applications.
        @returns: the default display, if it
   could be opened, otherwise %NULL.
        @rtype: Display
        """
        return object
    
    def beep(self):
        """        Emits a short beep on @display
        @returns: 
        @rtype: None
        """
        return object
    
    def close(self):
        """        Closes the connection to the windowing system for the given display,
        and cleans up associated resources.
        @returns: 
        @rtype: None
        """
        return object
    
    def device_is_grabbed(self, device=None):
        """        Returns %TRUE if there is an ongoing grab on @device for @display.
        @param device: a #GdkDevice
        @type device: Device
        @returns: %TRUE if there is a grab in effect for @device.
        @rtype: bool
        """
        return object
    
    def flush(self):
        """        Flushes any requests queued for the windowing system; this happens automatically
        when the main loop blocks waiting for new events, but if your application
        is drawing without returning control to the main loop, you may need
        to call this function explicitly. A common case where this function
        needs to be called is when an application is executing drawing commands
        from a thread other than the thread where the main loop is running.
        
        This is most useful for X11. On windowing systems where requests are
        handled synchronously, this function will do nothing.
        @returns: 
        @rtype: None
        """
        return object
    
    def get_app_launch_context(self):
        """        Returns a #GdkAppLaunchContext suitable for launching
        applications on the given display.
        @returns: a new #GdkAppLaunchContext for @display.
     Free with g_object_unref() when done
        @rtype: AppLaunchContext
        """
        return object
    
    def get_default_cursor_size(self):
        """        Returns the default size to use for cursors on @display.
        @returns: the default cursor size.
        @rtype: int
        """
        return object
    
    def get_default_group(self):
        """        Returns the default group leader window for all toplevel windows
        on @display. This window is implicitly created by GDK.
        See gdk_window_set_group().
        @returns: The default group leader window for @display
        @rtype: Window
        """
        return object
    
    def get_default_screen(self):
        """        Get the default #GdkScreen for @display.
        @returns: the default #GdkScreen object for @display
        @rtype: Screen
        """
        return object
    
    def get_default_seat(self):
        """        Returns the default #GdkSeat for this display.
        @returns: the default seat.
        @rtype: Seat
        """
        return object
    
    def get_device_manager(self):
        """        Returns the #GdkDeviceManager associated to @display.
        @returns: A #GdkDeviceManager, or
          %NULL. This memory is owned by GDK and must not be freed
          or unreferenced.
        @rtype: DeviceManager
        """
        return object
    
    def get_event(self):
        """        Gets the next #GdkEvent to be processed for @display, fetching events from the
        windowing system if necessary.
        @returns: the next #GdkEvent to be processed, or %NULL if no events are pending. The returned #GdkEvent should be freed with gdk_event_free().
        @rtype: Event
        """
        return object
    
    def get_maximal_cursor_size(self, width=None, height=None):
        """        Gets the maximal size to use for cursors on @display.
        @param width: the return location for the maximal cursor width
        @param height: the return location for the maximal cursor height
        @type width: int
        @type height: int
        @returns: 
        @rtype: None
        """
        return object
    
    def get_monitor(self, monitor_num=None):
        """        Gets a monitor associated with this display.
        @param monitor_num: number of the monitor
        @type monitor_num: int
        @returns: the #GdkMonitor, or %NULL if
    @monitor_num is not a valid monitor number
        @rtype: Monitor
        """
        return object
    
    def get_monitor_at_point(self, x=None, y=None):
        """        Gets the monitor in which the point (@x, @y) is located,
        or a nearby monitor if the point is not in any monitor.
        @param x: the x coordinate of the point
        @param y: the y coordinate of the point
        @type x: int
        @type y: int
        @returns: the monitor containing the point
        @rtype: Monitor
        """
        return object
    
    def get_monitor_at_window(self, window=None):
        """        Gets the monitor in which the largest area of @window
        resides, or a monitor close to @window if it is outside
        of all monitors.
        @param window: a #GdkWindow
        @type window: Window
        @returns: the monitor with the largest overlap with @window
        @rtype: Monitor
        """
        return object
    
    def get_n_monitors(self):
        """        Gets the number of monitors that belong to @display.
        
        The returned number is valid until the next emission of the
        #GdkDisplay::monitor-added or #GdkDisplay::monitor-removed signal.
        @returns: the number of monitors
        @rtype: int
        """
        return object
    
    def get_n_screens(self):
        """        Gets the number of screen managed by the @display.
        @returns: number of screens.
        @rtype: int
        """
        return object
    
    def get_name(self):
        """        Gets the name of the display.
        @returns: a string representing the display name. This string is owned by GDK and should not be modified or freed.
        @rtype: str
        """
        return object
    
    def get_pointer(self, screen=None, x=None, y=None, mask=None):
        """        Gets the current location of the pointer and the current modifier
        mask for a given display.
        @param screen: location to store the screen that the          cursor is on, or %NULL.
        @param x: location to store root window X coordinate of pointer, or %NULL.
        @param y: location to store root window Y coordinate of pointer, or %NULL.
        @param mask: location to store current modifier mask, or %NULL
        @type screen: Screen
        @type x: int
        @type y: int
        @type mask: ModifierType
        @returns: 
        @rtype: None
        """
        return object
    
    def get_primary_monitor(self):
        """        Gets the primary monitor for the display.
        
        The primary monitor is considered the monitor where the “main desktop”
        lives. While normal application windows typically allow the window
        manager to place the windows, specialized desktop applications
        such as panels should place themselves on the primary monitor.
        @returns: the primary monitor, or %NULL if no primary
     monitor is configured by the user
        @rtype: Monitor
        """
        return object
    
    def get_screen(self, screen_num=None):
        """        Returns a screen object for one of the screens of the display.
        @param screen_num: the screen number
        @type screen_num: int
        @returns: the #GdkScreen object
        @rtype: Screen
        """
        return object
    
    def get_window_at_pointer(self, win_x=None, win_y=None):
        """        Obtains the window underneath the mouse pointer, returning the location
        of the pointer in that window in @win_x, @win_y for @screen. Returns %NULL
        if the window under the mouse pointer is not known to GDK (for example,
        belongs to another application).
        @param win_x: return location for x coordinate of the pointer location relative    to the window origin, or %NULL
        @param win_y: return location for y coordinate of the pointer location relative  &    to the window origin, or %NULL
        @type win_x: int
        @type win_y: int
        @returns: the window under the mouse
   pointer, or %NULL
        @rtype: Window
        """
        return object
    
    def has_pending(self):
        """        Returns whether the display has events that are waiting
        to be processed.
        @returns: %TRUE if there are events ready to be processed.
        @rtype: bool
        """
        return object
    
    def is_closed(self):
        """        Finds out if the display has been closed.
        @returns: %TRUE if the display is closed.
        @rtype: bool
        """
        return object
    
    def keyboard_ungrab(self, time_=None):
        """        Release any keyboard grab
        @param time_: a timestap (e.g #GDK_CURRENT_TIME).
        @type time_: guint32
        @returns: 
        @rtype: None
        """
        return object
    
    def list_devices(self):
        """        Returns the list of available input devices attached to @display.
        The list is statically allocated and should not be freed.
        @returns: a list of #GdkDevice
        @rtype: GLib.List
        """
        return object
    
    def list_seats(self):
        """        Returns the list of seats known to @display.
        @returns: the
          list of seats known to the #GdkDisplay
        @rtype: GLib.List
        """
        return object
    
    def notify_startup_complete(self, startup_id=None):
        """        Indicates to the GUI environment that the application has
        finished loading, using a given identifier.
        
        GTK+ will call this function automatically for #GtkWindow
        with custom startup-notification identifier unless
        gtk_window_set_auto_startup_notification() is called to
        disable that feature.
        @param startup_id: a startup-notification identifier, for which     notification process should be completed
        @type startup_id: str
        @returns: 
        @rtype: None
        """
        return object
    
    def peek_event(self):
        """        Gets a copy of the first #GdkEvent in the @display’s event queue, without
        removing the event from the queue.  (Note that this function will
        not get more events from the windowing system.  It only checks the events
        that have already been moved to the GDK event queue.)
        @returns: a copy of the first #GdkEvent on the event queue, or %NULL if no events are in the queue. The returned #GdkEvent should be freed with gdk_event_free().
        @rtype: Event
        """
        return object
    
    def pointer_is_grabbed(self):
        """        Test if the pointer is grabbed.
        @returns: %TRUE if an active X pointer grab is in effect
        @rtype: bool
        """
        return object
    
    def pointer_ungrab(self, time_=None):
        """        Release any pointer grab.
        @param time_: a timestap (e.g. %GDK_CURRENT_TIME).
        @type time_: guint32
        @returns: 
        @rtype: None
        """
        return object
    
    def put_event(self, event=None):
        """        Appends a copy of the given event onto the front of the event
        queue for @display.
        @param event: a #GdkEvent.
        @type event: Event
        @returns: 
        @rtype: None
        """
        return object
    
    def request_selection_notification(self, selection=None):
        """        Request #GdkEventOwnerChange events for ownership changes
        of the selection named by the given atom.
        @param selection: the #GdkAtom naming the selection for which             ownership change notification is requested
        @type selection: Atom
        @returns: whether #GdkEventOwnerChange events will
               be sent.
        @rtype: bool
        """
        return object
    
    def set_double_click_distance(self, distance=None):
        """        Sets the double click distance (two clicks within this distance
        count as a double click and result in a #GDK_2BUTTON_PRESS event).
        See also gdk_display_set_double_click_time().
        Applications should not set this, it is a global
        user-configured setting.
        @param distance: distance in pixels
        @type distance: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_double_click_time(self, msec=None):
        """        Sets the double click time (two clicks within this time interval
        count as a double click and result in a #GDK_2BUTTON_PRESS event).
        Applications should not set this, it is a global
        user-configured setting.
        @param msec: double click time in milliseconds (thousandths of a second)
        @type msec: int
        @returns: 
        @rtype: None
        """
        return object
    
    def store_clipboard(self, clipboard_window=None, time_=None, targets=None, n_targets=None):
        """        Issues a request to the clipboard manager to store the
        clipboard data. On X11, this is a special program that works
        according to the
        [FreeDesktop Clipboard Specification](http://www.freedesktop.org/Standards/clipboard-manager-spec).
        @param clipboard_window: a #GdkWindow belonging to the clipboard owner
        @param time_: a timestamp
        @param targets: an array of targets                    that should be saved, or %NULL                    if all available targets should be saved.
        @param n_targets: length of the @targets array
        @type clipboard_window: Window
        @type time_: guint32
        @type n_targets: int
        @returns: 
        @rtype: None
        """
        return object
    
    def supports_clipboard_persistence(self):
        """        Returns whether the speicifed display supports clipboard
        persistance; i.e. if it’s possible to store the clipboard data after an
        application has quit. On X11 this checks if a clipboard daemon is
        running.
        @returns: %TRUE if the display supports clipboard persistance.
        @rtype: bool
        """
        return object
    
    def supports_composite(self):
        """        Returns %TRUE if gdk_window_set_composited() can be used
        to redirect drawing on the window using compositing.
        
        Currently this only works on X11 with XComposite and
        XDamage extensions available.
        @returns: %TRUE if windows may be composited.
        @rtype: bool
        """
        return object
    
    def supports_cursor_alpha(self):
        """        Returns %TRUE if cursors can use an 8bit alpha channel
        on @display. Otherwise, cursors are restricted to bilevel
        alpha (i.e. a mask).
        @returns: whether cursors can have alpha channels.
        @rtype: bool
        """
        return object
    
    def supports_cursor_color(self):
        """        Returns %TRUE if multicolored cursors are supported
        on @display. Otherwise, cursors have only a forground
        and a background color.
        @returns: whether cursors can have multiple colors.
        @rtype: bool
        """
        return object
    
    def supports_input_shapes(self):
        """        Returns %TRUE if gdk_window_input_shape_combine_mask() can
        be used to modify the input shape of windows on @display.
        @returns: %TRUE if windows with modified input shape are supported
        @rtype: bool
        """
        return object
    
    def supports_selection_notification(self):
        """        Returns whether #GdkEventOwnerChange events will be
        sent when the owner of a selection changes.
        @returns: whether #GdkEventOwnerChange events will
               be sent.
        @rtype: bool
        """
        return object
    
    def supports_shapes(self):
        """        Returns %TRUE if gdk_window_shape_combine_mask() can
        be used to create shaped windows on @display.
        @returns: %TRUE if shaped windows are supported
        @rtype: bool
        """
        return object
    
    def sync(self):
        """        Flushes any requests queued for the windowing system and waits until all
        requests have been handled. This is often used for making sure that the
        display is synchronized with the current state of the program. Calling
        gdk_display_sync() before gdk_error_trap_pop() makes sure that any errors
        generated from earlier requests are handled before the error trap is
        removed.
        
        This is most useful for X11. On windowing systems where requests are
        handled synchronously, this function will do nothing.
        @returns: 
        @rtype: None
        """
        return object
    
    def warp_pointer(self, screen=None, x=None, y=None):
        """        Warps the pointer of @display to the point @x,@y on
        the screen @screen, unless the pointer is confined
        to a window by a grab, in which case it will be moved
        as far as allowed by the grab. Warping the pointer
        creates events as if the user had moved the mouse
        instantaneously to the destination.
        
        Note that the pointer should normally be under the
        control of the user. This function was added to cover
        some rare use cases like keyboard navigation support
        for the color picker in the #GtkColorSelectionDialog.
        @param screen: the screen of @display to warp the pointer to
        @param x: the x coordinate of the destination
        @param y: the y coordinate of the destination
        @type screen: Screen
        @type x: int
        @type y: int
        @returns: 
        @rtype: None
        """
        return object


class DisplayManager(GObject.Object):
    """The purpose of the #GdkDisplayManager singleton object is to offer
notification when displays appear or disappear or the default display
changes.

You can use gdk_display_manager_get() to obtain the #GdkDisplayManager
singleton, but that should be rarely necessary. Typically, initializing
GTK+ opens a display that you can work with without ever accessing the
#GdkDisplayManager.

The GDK library can be built with support for multiple backends.
The #GdkDisplayManager object determines which backend is used
at runtime.

When writing backend-specific code that is supposed to work with
multiple GDK backends, you have to consider both compile time and
runtime. At compile time, use the #GDK_WINDOWING_X11, #GDK_WINDOWING_WIN32
macros, etc. to find out which backends are present in the GDK library
you are building your application against. At runtime, use type-check
macros like GDK_IS_X11_DISPLAY() to find out which backend is in use:

## Backend-specific code ## {#backend-specific}

|[<!-- language="C" -->
#ifdef GDK_WINDOWING_X11
  if (GDK_IS_X11_DISPLAY (display))
    {
      // make X11-specific calls here
    }
  else
#endif
#ifdef GDK_WINDOWING_QUARTZ
  if (GDK_IS_QUARTZ_DISPLAY (display))
    {
      // make Quartz-specific calls here
    }
  else
#endif
  g_error ("Unsupported GDK backend");
]|"""
    @staticmethod
    def get():
        """        Gets the singleton #GdkDisplayManager object.
        
        When called for the first time, this function consults the
        `GDK_BACKEND` environment variable to find out which
        of the supported GDK backends to use (in case GDK has been compiled
        with multiple backends). Applications can use gdk_set_allowed_backends()
        to limit what backends can be used.
        @returns: The global #GdkDisplayManager singleton;
     gdk_parse_args(), gdk_init(), or gdk_init_check() must have
     been called first.
        @rtype: DisplayManager
        """
        return object
    
    def get_default_display(self):
        """        Gets the default #GdkDisplay.
        @returns: a #GdkDisplay, or %NULL if
     there is no default display.
        @rtype: Display
        """
        return object
    
    def list_displays(self):
        """        List all currently open displays.
        @returns: a newly
     allocated #GSList of #GdkDisplay objects. Free with g_slist_free()
     when you are done with it.
        @rtype: GLib.SList
        """
        return object
    
    def open_display(self, name=None):
        """        Opens a display.
        @param name: the name of the display to open
        @type name: str
        @returns: a #GdkDisplay, or %NULL if the
     display could not be opened
        @rtype: Display
        """
        return object
    
    def set_default_display(self, display=None):
        """        Sets @display as the default display.
        @param display: a #GdkDisplay
        @type display: Display
        @returns: 
        @rtype: None
        """
        return object


class DragContext(GObject.Object):
    """"""
    
    def get_actions(self):
        """        Determines the bitmask of actions proposed by the source if
        gdk_drag_context_get_suggested_action() returns %GDK_ACTION_ASK.
        @returns: the #GdkDragAction flags
        @rtype: DragAction
        """
        return object
    
    def get_dest_window(self):
        """        Returns the destination windw for the DND operation.
        @returns: a #GdkWindow
        @rtype: Window
        """
        return object
    
    def get_device(self):
        """        Returns the #GdkDevice associated to the drag context.
        @returns: The #GdkDevice associated to @context.
        @rtype: Device
        """
        return object
    
    def get_drag_window(self):
        """        Returns the window on which the drag icon should be rendered
        during the drag operation. Note that the window may not be
        available until the drag operation has begun. GDK will move
        the window in accordance with the ongoing drag operation.
        The window is owned by @context and will be destroyed when
        the drag operation is over.
        @returns: the drag window, or %NULL
        @rtype: Window
        """
        return object
    
    def get_protocol(self):
        """        Returns the drag protocol thats used by this context.
        @returns: the drag protocol
        @rtype: DragProtocol
        """
        return object
    
    def get_selected_action(self):
        """        Determines the action chosen by the drag destination.
        @returns: a #GdkDragAction value
        @rtype: DragAction
        """
        return object
    
    def get_source_window(self):
        """        Returns the #GdkWindow where the DND operation started.
        @returns: a #GdkWindow
        @rtype: Window
        """
        return object
    
    def get_suggested_action(self):
        """        Determines the suggested drag action of the context.
        @returns: a #GdkDragAction value
        @rtype: DragAction
        """
        return object
    
    def list_targets(self):
        """        Retrieves the list of targets of the context.
        @returns: a #GList of targets
        @rtype: GLib.List
        """
        return object
    
    def manage_dnd(self, ipc_window=None, actions=None):
        """        Requests the drag and drop operation to be managed by @context.
        When a drag and drop operation becomes managed, the #GdkDragContext
        will internally handle all input and source-side #GdkEventDND events
        as required by the windowing system.
        
        Once the drag and drop operation is managed, the drag context will
        emit the following signals:
        - The #GdkDragContext::action-changed signal whenever the final action
          to be performed by the drag and drop operation changes.
        - The #GdkDragContext::drop-performed signal after the user performs
          the drag and drop gesture (typically by releasing the mouse button).
        - The #GdkDragContext::dnd-finished signal after the drag and drop
          operation concludes (after all #GdkSelection transfers happen).
        - The #GdkDragContext::cancel signal if the drag and drop operation is
          finished but doesn't happen over an accepting destination, or is
          cancelled through other means.
        @param ipc_window: Window to use for IPC messaging/events
        @param actions: the actions supported by the drag source
        @type ipc_window: Window
        @type actions: DragAction
        @returns: #TRUE if the drag and drop operation is managed.
        @rtype: bool
        """
        return object
    
    def set_device(self, device=None):
        """        Associates a #GdkDevice to @context, so all Drag and Drop events
        for @context are emitted as if they came from this device.
        @param device: a #GdkDevice
        @type device: Device
        @returns: 
        @rtype: None
        """
        return object
    
    def set_hotspot(self, hot_x=None, hot_y=None):
        """        Sets the position of the drag window that will be kept
        under the cursor hotspot. Initially, the hotspot is at the
        top left corner of the drag window.
        @param hot_x: x coordinate of the drag window hotspot
        @param hot_y: y coordinate of the drag window hotspot
        @type hot_x: int
        @type hot_y: int
        @returns: 
        @rtype: None
        """
        return object


class DrawingContext(GObject.Object):
    """#GdkDrawingContext is an object that represents the current drawing
state of a #GdkWindow.

It's possible to use a #GdkDrawingContext to draw on a #GdkWindow
via rendering API like Cairo or OpenGL.

A #GdkDrawingContext can only be created by calling gdk_window_begin_draw_frame()
and will be valid until a call to gdk_window_end_draw_frame().

#GdkDrawingContext is available since GDK 3.22"""
    
    def get_cairo_context(self):
        """        Retrieves a Cairo context to be used to draw on the #GdkWindow
        that created the #GdkDrawingContext.
        
        The returned context is guaranteed to be valid as long as the
        #GdkDrawingContext is valid, that is between a call to
        gdk_window_begin_draw_frame() and gdk_window_end_draw_frame().
        @returns: a Cairo context to be used to draw
   the contents of the #GdkWindow. The context is owned by the
   #GdkDrawingContext and should not be destroyed
        @rtype: cairo.Context
        """
        return object
    
    def get_clip(self):
        """        Retrieves a copy of the clip region used when creating the @context.
        @returns: a Cairo region
        @rtype: cairo.Region
        """
        return object
    
    def get_window(self):
        """        Retrieves the window that created the drawing @context.
        @returns: a #GdkWindow
        @rtype: Window
        """
        return object
    
    def is_valid(self):
        """        Checks whether the given #GdkDrawingContext is valid.
        @returns: %TRUE if the context is valid
        @rtype: bool
        """
        return object


class DrawingContextClass():
    """"""


class EventAny():
    """Contains the fields which are common to all event structs.
Any event pointer can safely be cast to a pointer to a #GdkEventAny to
access these fields."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object


class EventButton():
    """Used for button press and button release events. The
@type field will be one of %GDK_BUTTON_PRESS,
%GDK_2BUTTON_PRESS, %GDK_3BUTTON_PRESS or %GDK_BUTTON_RELEASE,

Double and triple-clicks result in a sequence of events being received.
For double-clicks the order of events will be:

- %GDK_BUTTON_PRESS
- %GDK_BUTTON_RELEASE
- %GDK_BUTTON_PRESS
- %GDK_2BUTTON_PRESS
- %GDK_BUTTON_RELEASE

Note that the first click is received just like a normal
button press, while the second click results in a %GDK_2BUTTON_PRESS
being received just after the %GDK_BUTTON_PRESS.

Triple-clicks are very similar to double-clicks, except that
%GDK_3BUTTON_PRESS is inserted after the third click. The order of the
events is:

- %GDK_BUTTON_PRESS
- %GDK_BUTTON_RELEASE
- %GDK_BUTTON_PRESS
- %GDK_2BUTTON_PRESS
- %GDK_BUTTON_RELEASE
- %GDK_BUTTON_PRESS
- %GDK_3BUTTON_PRESS
- %GDK_BUTTON_RELEASE

For a double click to occur, the second button press must occur within
1/4 of a second of the first. For a triple click to occur, the third
button press must also occur within 1/2 second of the first button press."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def time(self):
        return object

    @property
    def x(self):
        return object

    @property
    def y(self):
        return object

    @property
    def axes(self):
        return object

    @property
    def state(self):
        return object

    @property
    def button(self):
        return object

    @property
    def device(self):
        return object

    @property
    def x_root(self):
        return object

    @property
    def y_root(self):
        return object


class EventConfigure():
    """Generated when a window size or position has changed."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def x(self):
        return object

    @property
    def y(self):
        return object

    @property
    def width(self):
        return object

    @property
    def height(self):
        return object


class EventCrossing():
    """Generated when the pointer enters or leaves a window."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def subwindow(self):
        return object

    @property
    def time(self):
        return object

    @property
    def x(self):
        return object

    @property
    def y(self):
        return object

    @property
    def x_root(self):
        return object

    @property
    def y_root(self):
        return object

    @property
    def mode(self):
        return object

    @property
    def detail(self):
        return object

    @property
    def focus(self):
        return object

    @property
    def state(self):
        return object


class EventDND():
    """Generated during DND operations."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def context(self):
        return object

    @property
    def time(self):
        return object

    @property
    def x_root(self):
        return object

    @property
    def y_root(self):
        return object


class EventExpose():
    """Generated when all or part of a window becomes visible and needs to be
redrawn."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def area(self):
        return object

    @property
    def region(self):
        return object

    @property
    def count(self):
        return object


class EventFocus():
    """Describes a change of keyboard focus."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def in(self):
        return object


class EventGrabBroken():
    """Generated when a pointer or keyboard grab is broken. On X11, this happens
when the grab window becomes unviewable (i.e. it or one of its ancestors
is unmapped), or if the same application grabs the pointer or keyboard
again. Note that implicit grabs (which are initiated by button presses)
can also cause #GdkEventGrabBroken events."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def keyboard(self):
        return object

    @property
    def implicit(self):
        return object

    @property
    def grab_window(self):
        return object


class EventKey():
    """Describes a key press or key release event."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def time(self):
        return object

    @property
    def state(self):
        return object

    @property
    def keyval(self):
        return object

    @property
    def length(self):
        return object

    @property
    def string(self):
        return object

    @property
    def hardware_keycode(self):
        return object

    @property
    def group(self):
        return object

    @property
    def is_modifier(self):
        return object


class EventMotion():
    """Generated when the pointer moves."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def time(self):
        return object

    @property
    def x(self):
        return object

    @property
    def y(self):
        return object

    @property
    def axes(self):
        return object

    @property
    def state(self):
        return object

    @property
    def is_hint(self):
        return object

    @property
    def device(self):
        return object

    @property
    def x_root(self):
        return object

    @property
    def y_root(self):
        return object


class EventOwnerChange():
    """Generated when the owner of a selection changes. On X11, this
information is only available if the X server supports the XFIXES
extension."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def owner(self):
        return object

    @property
    def reason(self):
        return object

    @property
    def selection(self):
        return object

    @property
    def time(self):
        return object

    @property
    def selection_time(self):
        return object


class EventPadAxis():
    """Generated during %GDK_SOURCE_TABLET_PAD interaction with tactile sensors."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def time(self):
        return object

    @property
    def group(self):
        return object

    @property
    def index(self):
        return object

    @property
    def mode(self):
        return object

    @property
    def value(self):
        return object


class EventPadButton():
    """Generated during %GDK_SOURCE_TABLET_PAD button presses and releases."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def time(self):
        return object

    @property
    def group(self):
        return object

    @property
    def button(self):
        return object

    @property
    def mode(self):
        return object


class EventPadGroupMode():
    """Generated during %GDK_SOURCE_TABLET_PAD mode switches in a group."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def time(self):
        return object

    @property
    def group(self):
        return object

    @property
    def mode(self):
        return object


class EventProperty():
    """Describes a property change on a window."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def atom(self):
        return object

    @property
    def time(self):
        return object

    @property
    def state(self):
        return object


class EventProximity():
    """Proximity events are generated when using GDK’s wrapper for the
XInput extension. The XInput extension is an add-on for standard X
that allows you to use nonstandard devices such as graphics tablets.
A proximity event indicates that the stylus has moved in or out of
contact with the tablet, or perhaps that the user’s finger has moved
in or out of contact with a touch screen.

This event type will be used pretty rarely. It only is important for
XInput aware programs that are drawing their own cursor."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def time(self):
        return object

    @property
    def device(self):
        return object


class EventScroll():
    """Generated from button presses for the buttons 4 to 7. Wheel mice are
usually configured to generate button press events for buttons 4 and 5
when the wheel is turned.

Some GDK backends can also generate “smooth” scroll events, which
can be recognized by the %GDK_SCROLL_SMOOTH scroll direction. For
these, the scroll deltas can be obtained with
gdk_event_get_scroll_deltas()."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def time(self):
        return object

    @property
    def x(self):
        return object

    @property
    def y(self):
        return object

    @property
    def state(self):
        return object

    @property
    def direction(self):
        return object

    @property
    def device(self):
        return object

    @property
    def x_root(self):
        return object

    @property
    def y_root(self):
        return object

    @property
    def delta_x(self):
        return object

    @property
    def delta_y(self):
        return object

    @property
    def is_stop(self):
        return object


class EventSelection():
    """Generated when a selection is requested or ownership of a selection
is taken over by another client application."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def selection(self):
        return object

    @property
    def target(self):
        return object

    @property
    def property(self):
        return object

    @property
    def time(self):
        return object

    @property
    def requestor(self):
        return object


class EventSequence():
    """"""


class EventSetting():
    """Generated when a setting is modified."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def action(self):
        return object

    @property
    def name(self):
        return object


class EventTouch():
    """Used for touch events.
@type field will be one of %GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE,
%GDK_TOUCH_END or %GDK_TOUCH_CANCEL.

Touch events are grouped into sequences by means of the @sequence
field, which can also be obtained with gdk_event_get_event_sequence().
Each sequence begins with a %GDK_TOUCH_BEGIN event, followed by
any number of %GDK_TOUCH_UPDATE events, and ends with a %GDK_TOUCH_END
(or %GDK_TOUCH_CANCEL) event. With multitouch devices, there may be
several active sequences at the same time."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def time(self):
        return object

    @property
    def x(self):
        return object

    @property
    def y(self):
        return object

    @property
    def axes(self):
        return object

    @property
    def state(self):
        return object

    @property
    def sequence(self):
        return object

    @property
    def emulating_pointer(self):
        return object

    @property
    def device(self):
        return object

    @property
    def x_root(self):
        return object

    @property
    def y_root(self):
        return object


class EventTouchpadPinch():
    """Generated during touchpad swipe gestures."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def phase(self):
        return object

    @property
    def n_fingers(self):
        return object

    @property
    def time(self):
        return object

    @property
    def x(self):
        return object

    @property
    def y(self):
        return object

    @property
    def dx(self):
        return object

    @property
    def dy(self):
        return object

    @property
    def angle_delta(self):
        return object

    @property
    def scale(self):
        return object

    @property
    def x_root(self):
        return object

    @property
    def y_root(self):
        return object

    @property
    def state(self):
        return object


class EventTouchpadSwipe():
    """Generated during touchpad swipe gestures."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def phase(self):
        return object

    @property
    def n_fingers(self):
        return object

    @property
    def time(self):
        return object

    @property
    def x(self):
        return object

    @property
    def y(self):
        return object

    @property
    def dx(self):
        return object

    @property
    def dy(self):
        return object

    @property
    def x_root(self):
        return object

    @property
    def y_root(self):
        return object

    @property
    def state(self):
        return object


class EventVisibility():
    """Generated when the window visibility status has changed."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def state(self):
        return object


class EventWindowState():
    """Generated when the state of a toplevel window changes."""

    @property
    def type(self):
        return object

    @property
    def window(self):
        return object

    @property
    def send_event(self):
        return object

    @property
    def changed_mask(self):
        return object

    @property
    def new_window_state(self):
        return object


class FrameClock(GObject.Object):
    """A #GdkFrameClock tells the application when to update and repaint a
window. This may be synced to the vertical refresh rate of the
monitor, for example. Even when the frame clock uses a simple timer
rather than a hardware-based vertical sync, the frame clock helps
because it ensures everything paints at the same time (reducing the
total number of frames). The frame clock can also automatically
stop painting when it knows the frames will not be visible, or
scale back animation framerates.

#GdkFrameClock is designed to be compatible with an OpenGL-based
implementation or with mozRequestAnimationFrame in Firefox,
for example.

A frame clock is idle until someone requests a frame with
gdk_frame_clock_request_phase(). At some later point that makes
sense for the synchronization being implemented, the clock will
process a frame and emit signals for each phase that has been
requested. (See the signals of the #GdkFrameClock class for
documentation of the phases. %GDK_FRAME_CLOCK_PHASE_UPDATE and the
#GdkFrameClock::update signal are most interesting for application
writers, and are used to update the animations, using the frame time
given by gdk_frame_clock_get_frame_time().

The frame time is reported in microseconds and generally in the same
timescale as g_get_monotonic_time(), however, it is not the same
as g_get_monotonic_time(). The frame time does not advance during
the time a frame is being painted, and outside of a frame, an attempt
is made so that all calls to gdk_frame_clock_get_frame_time() that
are called at a “similar” time get the same value. This means that
if different animations are timed by looking at the difference in
time between an initial value from gdk_frame_clock_get_frame_time()
and the value inside the #GdkFrameClock::update signal of the clock,
they will stay exactly synchronized."""
    
    def begin_updating(self):
        """        Starts updates for an animation. Until a matching call to
        gdk_frame_clock_end_updating() is made, the frame clock will continually
        request a new frame with the %GDK_FRAME_CLOCK_PHASE_UPDATE phase.
        This function may be called multiple times and frames will be
        requested until gdk_frame_clock_end_updating() is called the same
        number of times.
        @returns: 
        @rtype: None
        """
        return object
    
    def end_updating(self):
        """        Stops updates for an animation. See the documentation for
        gdk_frame_clock_begin_updating().
        @returns: 
        @rtype: None
        """
        return object
    
    def get_current_timings(self):
        """        Gets the frame timings for the current frame.
        @returns: the #GdkFrameTimings for the frame currently  being processed, or even no frame is being processed, for the  previous frame. Before any frames have been processed, returns  %NULL.
        @rtype: FrameTimings
        """
        return object
    
    def get_frame_counter(self):
        """        A #GdkFrameClock maintains a 64-bit counter that increments for
        each frame drawn.
        @returns: inside frame processing, the value of the frame counter  for the current frame. Outside of frame processing, the frame
   counter for the last frame.
        @rtype: int
        """
        return object
    
    def get_frame_time(self):
        """        Gets the time that should currently be used for animations.  Inside
        the processing of a frame, it’s the time used to compute the
        animation position of everything in a frame. Outside of a frame, it's
        the time of the conceptual “previous frame,” which may be either
        the actual previous frame time, or if that’s too old, an updated
        time.
        @returns: a timestamp in microseconds, in the timescale of  of g_get_monotonic_time().
        @rtype: int
        """
        return object
    
    def get_history_start(self):
        """        #GdkFrameClock internally keeps a history of #GdkFrameTimings
        objects for recent frames that can be retrieved with
        gdk_frame_clock_get_timings(). The set of stored frames
        is the set from the counter values given by
        gdk_frame_clock_get_history_start() and
        gdk_frame_clock_get_frame_counter(), inclusive.
        @returns: the frame counter value for the oldest frame  that is available in the internal frame history of the  #GdkFrameClock.
        @rtype: int
        """
        return object
    
    def get_refresh_info(self, base_time=None, refresh_interval_return=None, presentation_time_return=None):
        """        Using the frame history stored in the frame clock, finds the last
        known presentation time and refresh interval, and assuming that
        presentation times are separated by the refresh interval,
        predicts a presentation time that is a multiple of the refresh
        interval after the last presentation time, and later than @base_time.
        @param base_time: base time for determining a presentaton time
        @param refresh_interval_return: a location to store the determined refresh interval, or %NULL. A default refresh interval of 1/60th of a second will be stored if no history is present.
        @param presentation_time_return: a location to store the next  candidate presentation time after the given base time.  0 will be will be stored if no history is present.
        @type base_time: int
        @type refresh_interval_return: int
        @type presentation_time_return: int
        @returns: 
        @rtype: None
        """
        return object
    
    def get_timings(self, frame_counter=None):
        """        Retrieves a #GdkFrameTimings object holding timing information
        for the current frame or a recent frame. The #GdkFrameTimings
        object may not yet be complete: see gdk_frame_timings_get_complete().
        @param frame_counter: the frame counter value identifying the frame to  be received.
        @type frame_counter: int
        @returns: the #GdkFrameTimings object for the specified  frame, or %NULL if it is not available. See  gdk_frame_clock_get_history_start().
        @rtype: FrameTimings
        """
        return object
    
    def request_phase(self, phase=None):
        """        Asks the frame clock to run a particular phase. The signal
        corresponding the requested phase will be emitted the next
        time the frame clock processes. Multiple calls to
        gdk_frame_clock_request_phase() will be combined together
        and only one frame processed. If you are displaying animated
        content and want to continually request the
        %GDK_FRAME_CLOCK_PHASE_UPDATE phase for a period of time,
        you should use gdk_frame_clock_begin_updating() instead, since
        this allows GTK+ to adjust system parameters to get maximally
        smooth animations.
        @param phase: the phase that is requested
        @type phase: FrameClockPhase
        @returns: 
        @rtype: None
        """
        return object


class FrameClockClass():
    """"""


class FrameClockPrivate():
    """"""


class FrameTimings():
    """A #GdkFrameTimings object holds timing information for a single frame
of the application’s displays. To retrieve #GdkFrameTimings objects,
use gdk_frame_clock_get_timings() or gdk_frame_clock_get_current_timings().
The information in #GdkFrameTimings is useful for precise synchronization
of video with the event or audio streams, and for measuring
quality metrics for the application’s display, such as latency and jitter."""
    
    def get_complete(self):
        """        The timing information in a #GdkFrameTimings is filled in
        incrementally as the frame as drawn and passed off to the
        window system for processing and display to the user. The
        accessor functions for #GdkFrameTimings can return 0 to
        indicate an unavailable value for two reasons: either because
        the information is not yet available, or because it isn't
        available at all. Once gdk_frame_timings_get_complete() returns
        %TRUE for a frame, you can be certain that no further values
        will become available and be stored in the #GdkFrameTimings.
        @returns: %TRUE if all information that will be available  for the frame has been filled in.
        @rtype: bool
        """
        return object
    
    def get_frame_counter(self):
        """        Gets the frame counter value of the #GdkFrameClock when this
        this frame was drawn.
        @returns: the frame counter value for this frame
        @rtype: int
        """
        return object
    
    def get_frame_time(self):
        """        Returns the frame time for the frame. This is the time value
        that is typically used to time animations for the frame. See
        gdk_frame_clock_get_frame_time().
        @returns: the frame time for the frame, in the timescale  of g_get_monotonic_time()
        @rtype: int
        """
        return object
    
    def get_predicted_presentation_time(self):
        """        Gets the predicted time at which this frame will be displayed. Although
        no predicted time may be available, if one is available, it will
        be available while the frame is being generated, in contrast to
        gdk_frame_timings_get_presentation_time(), which is only available
        after the frame has been presented. In general, if you are simply
        animating, you should use gdk_frame_clock_get_frame_time() rather
        than this function, but this function is useful for applications
        that want exact control over latency. For example, a movie player
        may want this information for Audio/Video synchronization.
        @returns: The predicted time at which the frame will be presented,  in the timescale of g_get_monotonic_time(), or 0 if no predicted  presentation time is available.
        @rtype: int
        """
        return object
    
    def get_presentation_time(self):
        """        Reurns the presentation time. This is the time at which the frame
        became visible to the user.
        @returns: the time the frame was displayed to the user, in the  timescale of g_get_monotonic_time(), or 0 if no presentation  time is available. See gdk_frame_timings_get_complete()
        @rtype: int
        """
        return object
    
    def get_refresh_interval(self):
        """        Gets the natural interval between presentation times for
        the display that this frame was displayed on. Frame presentation
        usually happens during the “vertical blanking interval”.
        @returns: the refresh interval of the display, in microseconds,  or 0 if the refresh interval is not available.  See gdk_frame_timings_get_complete().
        @rtype: int
        """
        return object
    
    def ref(self):
        """        Increases the reference count of @timings.
        @returns: @timings
        @rtype: FrameTimings
        """
        return object
    
    def unref(self):
        """        Decreases the reference count of @timings. If @timings
        is no longer referenced, it will be freed.
        @returns: 
        @rtype: None
        """
        return object


class GLContext(GObject.Object):
    """#GdkGLContext is an object representing the platform-specific
OpenGL drawing context.

#GdkGLContexts are created for a #GdkWindow using
gdk_window_create_gl_context(), and the context will match
the #GdkVisual of the window.

A #GdkGLContext is not tied to any particular normal framebuffer.
For instance, it cannot draw to the #GdkWindow back buffer. The GDK
repaint system is in full control of the painting to that. Instead,
you can create render buffers or textures and use gdk_cairo_draw_from_gl()
in the draw function of your widget to draw them. Then GDK will handle
the integration of your rendering with that of other widgets.

Support for #GdkGLContext is platform-specific, context creation
can fail, returning %NULL context.

A #GdkGLContext has to be made "current" in order to start using
it, otherwise any OpenGL call will be ignored.

## Creating a new OpenGL context ##

In order to create a new #GdkGLContext instance you need a
#GdkWindow, which you typically get during the realize call
of a widget.

A #GdkGLContext is not realized until either gdk_gl_context_make_current(),
or until it is realized using gdk_gl_context_realize(). It is possible to
specify details of the GL context like the OpenGL version to be used, or
whether the GL context should have extra state validation enabled after
calling gdk_window_create_gl_context() by calling gdk_gl_context_realize().
If the realization fails you have the option to change the settings of the
#GdkGLContext and try again.

## Using a GdkGLContext ##

You will need to make the #GdkGLContext the current context
before issuing OpenGL calls; the system sends OpenGL commands to
whichever context is current. It is possible to have multiple
contexts, so you always need to ensure that the one which you
want to draw with is the current one before issuing commands:

|[<!-- language="C" -->
  gdk_gl_context_make_current (context);
]|

You can now perform your drawing using OpenGL commands.

You can check which #GdkGLContext is the current one by using
gdk_gl_context_get_current(); you can also unset any #GdkGLContext
that is currently set by calling gdk_gl_context_clear_current()."""
    @staticmethod
    def clear_current():
        """        Clears the current #GdkGLContext.
        
        Any OpenGL call after this function returns will be ignored
        until gdk_gl_context_make_current() is called.
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def get_current():
        """        Retrieves the current #GdkGLContext.
        @returns: the current #GdkGLContext, or %NULL
        @rtype: GLContext
        """
        return object
    
    def get_debug_enabled(self):
        """        Retrieves the value set using gdk_gl_context_set_debug_enabled().
        @returns: %TRUE if debugging is enabled
        @rtype: bool
        """
        return object
    
    def get_display(self):
        """        Retrieves the #GdkDisplay the @context is created for
        @returns: a #GdkDisplay or %NULL
        @rtype: Display
        """
        return object
    
    def get_forward_compatible(self):
        """        Retrieves the value set using gdk_gl_context_set_forward_compatible().
        @returns: %TRUE if the context should be forward compatible
        @rtype: bool
        """
        return object
    
    def get_required_version(self, major=None, minor=None):
        """        Retrieves the major and minor version requested by calling
        gdk_gl_context_set_required_version().
        @param major: return location for the major version to request
        @param minor: return location for the minor version to request
        @type major: int
        @type minor: int
        @returns: 
        @rtype: None
        """
        return object
    
    def get_shared_context(self):
        """        Retrieves the #GdkGLContext that this @context share data with.
        @returns: a #GdkGLContext or %NULL
        @rtype: GLContext
        """
        return object
    
    def get_use_es(self):
        """        Checks whether the @context is using an OpenGL or OpenGL ES profile.
        @returns: %TRUE if the #GdkGLContext is using an OpenGL ES profile
        @rtype: bool
        """
        return object
    
    def get_version(self, major=None, minor=None):
        """        Retrieves the OpenGL version of the @context.
        
        The @context must be realized prior to calling this function.
        @param major: return location for the major version
        @param minor: return location for the minor version
        @type major: int
        @type minor: int
        @returns: 
        @rtype: None
        """
        return object
    
    def get_window(self):
        """        Retrieves the #GdkWindow used by the @context.
        @returns: a #GdkWindow or %NULL
        @rtype: Window
        """
        return object
    
    def is_legacy(self):
        """        Whether the #GdkGLContext is in legacy mode or not.
        
        The #GdkGLContext must be realized before calling this function.
        
        When realizing a GL context, GDK will try to use the OpenGL 3.2 core
        profile; this profile removes all the OpenGL API that was deprecated
        prior to the 3.2 version of the specification. If the realization is
        successful, this function will return %FALSE.
        
        If the underlying OpenGL implementation does not support core profiles,
        GDK will fall back to a pre-3.2 compatibility profile, and this function
        will return %TRUE.
        
        You can use the value returned by this function to decide which kind
        of OpenGL API to use, or whether to do extension discovery, or what
        kind of shader programs to load.
        @returns: %TRUE if the GL context is in legacy mode
        @rtype: bool
        """
        return object
    
    def make_current(self):
        """        Makes the @context the current one.
        @returns: 
        @rtype: None
        """
        return object
    
    def realize(self):
        """        Realizes the given #GdkGLContext.
        
        It is safe to call this function on a realized #GdkGLContext.
        @returns: %TRUE if the context is realized
        @rtype: bool
        """
        return object
    
    def set_debug_enabled(self, enabled=None):
        """        Sets whether the #GdkGLContext should perform extra validations and
        run time checking. This is useful during development, but has
        additional overhead.
        
        The #GdkGLContext must not be realized or made current prior to
        calling this function.
        @param enabled: whether to enable debugging in the context
        @type enabled: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def set_forward_compatible(self, compatible=None):
        """        Sets whether the #GdkGLContext should be forward compatible.
        
        Forward compatibile contexts must not support OpenGL functionality that
        has been marked as deprecated in the requested version; non-forward
        compatible contexts, on the other hand, must support both deprecated and
        non deprecated functionality.
        
        The #GdkGLContext must not be realized or made current prior to calling
        this function.
        @param compatible: whether the context should be forward compatible
        @type compatible: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def set_required_version(self, major=None, minor=None):
        """        Sets the major and minor version of OpenGL to request.
        
        Setting @major and @minor to zero will use the default values.
        
        The #GdkGLContext must not be realized or made current prior to calling
        this function.
        @param major: the major version to request
        @param minor: the minor version to request
        @type major: int
        @type minor: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_use_es(self, use_es=None):
        """        Requests that GDK create a OpenGL ES context instead of an OpenGL one,
        if the platform and windowing system allows it.
        
        The @context must not have been realized.
        
        By default, GDK will attempt to automatically detect whether the
        underlying GL implementation is OpenGL or OpenGL ES once the @context
        is realized.
        
        You should check the return value of gdk_gl_context_get_use_es() after
        calling gdk_gl_context_realize() to decide whether to use the OpenGL or
        OpenGL ES API, extensions, or shaders.
        @param use_es: whether the context should use OpenGL ES instead of OpenGL,   or -1 to allow auto-detection
        @type use_es: int
        @returns: 
        @rtype: None
        """
        return object


class Geometry():
    """The #GdkGeometry struct gives the window manager information about
a window’s geometry constraints. Normally you would set these on
the GTK+ level using gtk_window_set_geometry_hints(). #GtkWindow
then sets the hints on the #GdkWindow it creates.

gdk_window_set_geometry_hints() expects the hints to be fully valid already
and simply passes them to the window manager; in contrast,
gtk_window_set_geometry_hints() performs some interpretation. For example,
#GtkWindow will apply the hints to the geometry widget instead of the
toplevel window, if you set a geometry widget. Also, the
@min_width/@min_height/@max_width/@max_height fields may be set to -1, and
#GtkWindow will substitute the size request of the window or geometry widget.
If the minimum size hint is not provided, #GtkWindow will use its requisition
as the minimum size. If the minimum size is provided and a geometry widget is
set, #GtkWindow will take the minimum size as the minimum size of the
geometry widget rather than the entire window. The base size is treated
similarly.

The canonical use-case for gtk_window_set_geometry_hints() is to get a
terminal widget to resize properly. Here, the terminal text area should be
the geometry widget; #GtkWindow will then automatically set the base size to
the size of other widgets in the terminal window, such as the menubar and
scrollbar. Then, the @width_inc and @height_inc fields should be set to the
size of one character in the terminal. Finally, the base size should be set
to the size of one character. The net effect is that the minimum size of the
terminal will have a 1x1 character terminal area, and only terminal sizes on
the “character grid” will be allowed.

Here’s an example of how the terminal example would be implemented, assuming
a terminal area widget called “terminal” and a toplevel window “toplevel”:

|[<!-- language="C" -->
	GdkGeometry hints;

	hints.base_width = terminal->char_width;
        hints.base_height = terminal->char_height;
        hints.min_width = terminal->char_width;
        hints.min_height = terminal->char_height;
        hints.width_inc = terminal->char_width;
        hints.height_inc = terminal->char_height;

 gtk_window_set_geometry_hints (GTK_WINDOW (toplevel),
                                GTK_WIDGET (terminal),
                                &hints,
                                GDK_HINT_RESIZE_INC |
                                GDK_HINT_MIN_SIZE |
                                GDK_HINT_BASE_SIZE);
]|

The other useful fields are the @min_aspect and @max_aspect fields; these
contain a width/height ratio as a floating point number. If a geometry widget
is set, the aspect applies to the geometry widget rather than the entire
window. The most common use of these hints is probably to set @min_aspect and
@max_aspect to the same value, thus forcing the window to keep a constant
aspect ratio."""

    @property
    def min_width(self):
        return object

    @property
    def min_height(self):
        return object

    @property
    def max_width(self):
        return object

    @property
    def max_height(self):
        return object

    @property
    def base_width(self):
        return object

    @property
    def base_height(self):
        return object

    @property
    def width_inc(self):
        return object

    @property
    def height_inc(self):
        return object

    @property
    def min_aspect(self):
        return object

    @property
    def max_aspect(self):
        return object

    @property
    def win_gravity(self):
        return object


class Keymap(GObject.Object):
    """A #GdkKeymap defines the translation from keyboard state
(including a hardware key, a modifier mask, and active keyboard group)
to a keyval. This translation has two phases. The first phase is
to determine the effective keyboard group and level for the keyboard
state; the second phase is to look up the keycode/group/level triplet
in the keymap and see what keyval it corresponds to."""
    @staticmethod
    def get_default():
        """        Returns the #GdkKeymap attached to the default display.
        @returns: the #GdkKeymap attached to the default display.
        @rtype: Keymap
        """
        return object
    @staticmethod
    def get_for_display(display=None):
        """        Returns the #GdkKeymap attached to @display.
        @param display: the #GdkDisplay.
        @type display: Display
        @returns: the #GdkKeymap attached to @display.
        @rtype: Keymap
        """
        return object
    
    def add_virtual_modifiers(self, state=None):
        """        Maps the non-virtual modifiers (i.e Mod2, Mod3, ...) which are set
        in @state to the virtual modifiers (i.e. Super, Hyper and Meta) and
        set the corresponding bits in @state.
        
        GDK already does this before delivering key events, but for
        compatibility reasons, it only sets the first virtual modifier
        it finds, whereas this function sets all matching virtual modifiers.
        
        This function is useful when matching key events against
        accelerators.
        @param state: pointer to the modifier mask to change
        @type state: ModifierType
        @returns: 
        @rtype: None
        """
        return object
    
    def get_caps_lock_state(self):
        """        Returns whether the Caps Lock modifer is locked.
        @returns: %TRUE if Caps Lock is on
        @rtype: bool
        """
        return object
    
    def get_direction(self):
        """        Returns the direction of effective layout of the keymap.
        @returns: %PANGO_DIRECTION_LTR or %PANGO_DIRECTION_RTL
   if it can determine the direction. %PANGO_DIRECTION_NEUTRAL
   otherwise.
        @rtype: Pango.Direction
        """
        return object
    
    def get_entries_for_keycode(self, hardware_keycode=None, keys=None, keyvals=None, n_entries=None):
        """        Returns the keyvals bound to @hardware_keycode.
        The Nth #GdkKeymapKey in @keys is bound to the Nth
        keyval in @keyvals. Free the returned arrays with g_free().
        When a keycode is pressed by the user, the keyval from
        this list of entries is selected by considering the effective
        keyboard group and level. See gdk_keymap_translate_keyboard_state().
        @param hardware_keycode: a keycode
        @param keys: return     location for array of #GdkKeymapKey, or %NULL
        @param keyvals: return     location for array of keyvals, or %NULL
        @param n_entries: length of @keys and @keyvals
        @type hardware_keycode: int
        @type n_entries: int
        @returns: %TRUE if there were any entries
        @rtype: bool
        """
        return object
    
    def get_entries_for_keyval(self, keyval=None, keys=None, n_keys=None):
        """        Obtains a list of keycode/group/level combinations that will
        generate @keyval. Groups and levels are two kinds of keyboard mode;
        in general, the level determines whether the top or bottom symbol
        on a key is used, and the group determines whether the left or
        right symbol is used. On US keyboards, the shift key changes the
        keyboard level, and there are no groups. A group switch key might
        convert a keyboard between Hebrew to English modes, for example.
        #GdkEventKey contains a %group field that indicates the active
        keyboard group. The level is computed from the modifier mask.
        The returned array should be freed
        with g_free().
        @param keyval: a keyval, such as %GDK_KEY_a, %GDK_KEY_Up, %GDK_KEY_Return, etc.
        @param keys: return location     for an array of #GdkKeymapKey
        @param n_keys: return location for number of elements in returned array
        @type keyval: int
        @type n_keys: int
        @returns: %TRUE if keys were found and returned
        @rtype: bool
        """
        return object
    
    def get_modifier_mask(self, intent=None):
        """        Returns the modifier mask the @keymap’s windowing system backend
        uses for a particular purpose.
        
        Note that this function always returns real hardware modifiers, not
        virtual ones (e.g. it will return #GDK_MOD1_MASK rather than
        #GDK_META_MASK if the backend maps MOD1 to META), so there are use
        cases where the return value of this function has to be transformed
        by gdk_keymap_add_virtual_modifiers() in order to contain the
        expected result.
        @param intent: the use case for the modifier mask
        @type intent: ModifierIntent
        @returns: the modifier mask used for @intent.
        @rtype: ModifierType
        """
        return object
    
    def get_modifier_state(self):
        """        Returns the current modifier state.
        @returns: the current modifier state.
        @rtype: int
        """
        return object
    
    def get_num_lock_state(self):
        """        Returns whether the Num Lock modifer is locked.
        @returns: %TRUE if Num Lock is on
        @rtype: bool
        """
        return object
    
    def get_scroll_lock_state(self):
        """        Returns whether the Scroll Lock modifer is locked.
        @returns: %TRUE if Scroll Lock is on
        @rtype: bool
        """
        return object
    
    def have_bidi_layouts(self):
        """        Determines if keyboard layouts for both right-to-left and left-to-right
        languages are in use.
        @returns: %TRUE if there are layouts in both directions, %FALSE otherwise
        @rtype: bool
        """
        return object
    
    def lookup_key(self, key=None):
        """        Looks up the keyval mapped to a keycode/group/level triplet.
        If no keyval is bound to @key, returns 0. For normal user input,
        you want to use gdk_keymap_translate_keyboard_state() instead of
        this function, since the effective group/level may not be
        the same as the current keyboard state.
        @param key: a #GdkKeymapKey with keycode, group, and level initialized
        @type key: KeymapKey
        @returns: a keyval, or 0 if none was mapped to the given @key
        @rtype: int
        """
        return object
    
    def map_virtual_modifiers(self, state=None):
        """        Maps the virtual modifiers (i.e. Super, Hyper and Meta) which
        are set in @state to their non-virtual counterparts (i.e. Mod2,
        Mod3,...) and set the corresponding bits in @state.
        
        This function is useful when matching key events against
        accelerators.
        @param state: pointer to the modifier state to map
        @type state: ModifierType
        @returns: %FALSE if two virtual modifiers were mapped to the
     same non-virtual modifier. Note that %FALSE is also returned
     if a virtual modifier is mapped to a non-virtual modifier that
     was already set in @state.
        @rtype: bool
        """
        return object
    
    def translate_keyboard_state(self, hardware_keycode=None, state=None, group=None, keyval=None, effective_group=None, level=None, consumed_modifiers=None):
        """        Translates the contents of a #GdkEventKey into a keyval, effective
        group, and level. Modifiers that affected the translation and
        are thus unavailable for application use are returned in
        @consumed_modifiers.
        See [Groups][key-group-explanation] for an explanation of
        groups and levels. The @effective_group is the group that was
        actually used for the translation; some keys such as Enter are not
        affected by the active keyboard group. The @level is derived from
        @state. For convenience, #GdkEventKey already contains the translated
        keyval, so this function isn’t as useful as you might think.
        
        @consumed_modifiers gives modifiers that should be masked outfrom @state
        when comparing this key press to a hot key. For instance, on a US keyboard,
        the `plus` symbol is shifted, so when comparing a key press to a
        `<Control>plus` accelerator `<Shift>` should be masked out.
        
        |[<!-- language="C" -->
        // We want to ignore irrelevant modifiers like ScrollLock
        #define ALL_ACCELS_MASK (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK)
        gdk_keymap_translate_keyboard_state (keymap, event->hardware_keycode,
                                             event->state, event->group,
                                             &keyval, NULL, NULL, &consumed);
        if (keyval == GDK_PLUS &&
            (event->state & ~consumed & ALL_ACCELS_MASK) == GDK_CONTROL_MASK)
          // Control was pressed
        ]|
        
        An older interpretation @consumed_modifiers was that it contained
        all modifiers that might affect the translation of the key;
        this allowed accelerators to be stored with irrelevant consumed
        modifiers, by doing:
        |[<!-- language="C" -->
        // XXX Don’t do this XXX
        if (keyval == accel_keyval &&
            (event->state & ~consumed & ALL_ACCELS_MASK) == (accel_mods & ~consumed))
          // Accelerator was pressed
        ]|
        
        However, this did not work if multi-modifier combinations were
        used in the keymap, since, for instance, `<Control>` would be
        masked out even if only `<Control><Alt>` was used in the keymap.
        To support this usage as well as well as possible, all single
        modifier combinations that could affect the key for any combination
        of modifiers will be returned in @consumed_modifiers; multi-modifier
        combinations are returned only when actually found in @state. When
        you store accelerators, you should always store them with consumed
        modifiers removed. Store `<Control>plus`, not `<Control><Shift>plus`,
        @param hardware_keycode: a keycode
        @param state: a modifier state
        @param group: active keyboard group
        @param keyval: return location for keyval, or %NULL
        @param effective_group: return location for effective     group, or %NULL
        @param level: return location for level, or %NULL
        @param consumed_modifiers: return location for modifiers     that were used to determine the group or level, or %NULL
        @type hardware_keycode: int
        @type state: ModifierType
        @type group: int
        @type keyval: int
        @type effective_group: int
        @type level: int
        @type consumed_modifiers: ModifierType
        @returns: %TRUE if there was a keyval bound to the keycode/state/group
        @rtype: bool
        """
        return object


class KeymapKey():
    """A #GdkKeymapKey is a hardware key that can be mapped to a keyval."""

    @property
    def keycode(self):
        return object

    @property
    def group(self):
        return object

    @property
    def level(self):
        return object


class Monitor(GObject.Object):
    """GdkMonitor objects represent the individual outputs that are
associated with a #GdkDisplay. GdkDisplay has APIs to enumerate
monitors with gdk_display_get_n_monitors() and gdk_display_get_monitor(), and
to find particular monitors with gdk_display_get_primary_monitor() or
gdk_display_get_monitor_at_window().

GdkMonitor was introduced in GTK+ 3.22 and supersedes earlier
APIs in GdkScreen to obtain monitor-related information."""
    
    def get_display(self):
        """        Gets the display that this monitor belongs to.
        @returns: the display
        @rtype: Display
        """
        return object
    
    def get_geometry(self, geometry=None):
        """        Retrieves the size and position of an individual monitor within the
        display coordinate space. The returned geometry is in  ”application pixels”,
        not in ”device pixels” (see gdk_monitor_get_scale_factor()).
        @param geometry: a #GdkRectangle to be filled with the monitor geometry
        @type geometry: Rectangle
        @returns: 
        @rtype: None
        """
        return object
    
    def get_height_mm(self):
        """        Gets the height in millimeters of the monitor.
        @returns: the physical height of the monitor
        @rtype: int
        """
        return object
    
    def get_manufacturer(self):
        """        Gets the name of the monitor's manufacturer, if available.
        @returns: the name of the manufacturer, or %NULL
        @rtype: str
        """
        return object
    
    def get_model(self):
        """        Gets the a string identifying the monitor model, if available.
        @returns: the monitor model, or %NULL
        @rtype: str
        """
        return object
    
    def get_refresh_rate(self):
        """        Gets the refresh rate of the monitor, if available.
        
        The value is in milli-Hertz, so a refresh rate of 60Hz
        is returned as 60000.
        @returns: the refresh rate in milli-Hertz, or 0
        @rtype: int
        """
        return object
    
    def get_scale_factor(self):
        """        Gets the internal scale factor that maps from monitor coordinates
        to the actual device pixels. On traditional systems this is 1, but
        on very high density outputs this can be a higher value (often 2).
        
        This can be used if you want to create pixel based data for a
        particular monitor, but most of the time you’re drawing to a window
        where it is better to use gdk_window_get_scale_factor() instead.
        @returns: the scale factor
        @rtype: int
        """
        return object
    
    def get_subpixel_layout(self):
        """        Gets information about the layout of red, green and blue
        primaries for each pixel in this monitor, if available.
        @returns: the subpixel layout
        @rtype: SubpixelLayout
        """
        return object
    
    def get_width_mm(self):
        """        Gets the width in millimeters of the monitor.
        @returns: the physical width of the monitor
        @rtype: int
        """
        return object
    
    def get_workarea(self, workarea=None):
        """        Retrieves the size and position of the “work area” on a monitor
        within the display coordinate space. The returned geometry is in
        ”application pixels”, not in ”device pixels” (see
        gdk_monitor_get_scale_factor()).
        
        The work area should be considered when positioning menus and
        similar popups, to avoid placing them below panels, docks or other
        desktop components.
        
        Note that not all backends may have a concept of workarea. This
        function will return the monitor geometry if a workarea is not
        available, or does not apply.
        @param workarea: a #GdkRectangle to be filled with     the monitor workarea
        @type workarea: Rectangle
        @returns: 
        @rtype: None
        """
        return object
    
    def is_primary(self):
        """        Gets whether this monitor should be considered primary
        (see gdk_display_get_primary_monitor()).
        @returns: %TRUE if @monitor is primary
        @rtype: bool
        """
        return object


class MonitorClass():
    """"""


class Point():
    """Defines the x and y coordinates of a point."""

    @property
    def x(self):
        return object

    @property
    def y(self):
        return object


class RGBA():
    """A #GdkRGBA is used to represent a (possibly translucent)
color, in a way that is compatible with cairo’s notion of color."""
    
    def copy(self):
        """        Makes a copy of a #GdkRGBA.
        
        The result must be freed through gdk_rgba_free().
        @returns: A newly allocated #GdkRGBA, with the same contents as @rgba
        @rtype: RGBA
        """
        return object
    
    def equal(self, p2=None):
        """        Compares two RGBA colors.
        @param p2: another #GdkRGBA pointer
        @type p2: RGBA
        @returns: %TRUE if the two colors compare equal
        @rtype: bool
        """
        return object
    
    def free(self):
        """        Frees a #GdkRGBA created with gdk_rgba_copy()
        @returns: 
        @rtype: None
        """
        return object
    
    def hash(self):
        """        A hash function suitable for using for a hash
        table that stores #GdkRGBAs.
        @returns: The hash value for @p
        @rtype: int
        """
        return object
    
    def parse(self, spec=None):
        """        Parses a textual representation of a color, filling in
        the @red, @green, @blue and @alpha fields of the @rgba #GdkRGBA.
        
        The string can be either one of:
        - A standard name (Taken from the X11 rgb.txt file).
        - A hexadecimal value in the form “\#rgb”, “\#rrggbb”,
          “\#rrrgggbbb” or ”\#rrrrggggbbbb”
        - A RGB color in the form “rgb(r,g,b)” (In this case the color will
          have full opacity)
        - A RGBA color in the form “rgba(r,g,b,a)”
        
        Where “r”, “g”, “b” and “a” are respectively the red, green, blue and
        alpha color values. In the last two cases, r g and b are either integers
        in the range 0 to 255 or percentage values in the range 0% to 100%, and
        a is a floating point value in the range 0 to 1.
        @param spec: the string specifying the color
        @type spec: str
        @returns: %TRUE if the parsing succeeded
        @rtype: bool
        """
        return object
    
    def to_string(self):
        """        Returns a textual specification of @rgba in the form
        `rgb (r, g, b)` or
        `rgba (r, g, b, a)`,
        where “r”, “g”, “b” and “a” represent the red, green,
        blue and alpha values respectively. r, g, and b are
        represented as integers in the range 0 to 255, and a
        is represented as floating point value in the range 0 to 1.
        
        These string forms are string forms those supported by
        the CSS3 colors module, and can be parsed by gdk_rgba_parse().
        
        Note that this string representation may lose some
        precision, since r, g and b are represented as 8-bit
        integers. If this is a concern, you should use a
        different representation.
        @returns: A newly allocated text string
        @rtype: str
        """
        return object

    @property
    def red(self):
        return object

    @property
    def green(self):
        return object

    @property
    def blue(self):
        return object

    @property
    def alpha(self):
        return object


class Rectangle():
    """Defines the position and size of a rectangle. It is identical to
#cairo_rectangle_int_t."""
    
    def equal(self, rect2=None):
        """        Checks if the two given rectangles are equal.
        @param rect2: a #GdkRectangle
        @type rect2: Rectangle
        @returns: %TRUE if the rectangles are equal.
        @rtype: bool
        """
        return object
    
    def intersect(self, src2=None, dest=None):
        """        Calculates the intersection of two rectangles. It is allowed for
        @dest to be the same as either @src1 or @src2. If the rectangles
        do not intersect, @dest’s width and height is set to 0 and its x
        and y values are undefined. If you are only interested in whether
        the rectangles intersect, but not in the intersecting area itself,
        pass %NULL for @dest.
        @param src2: a #GdkRectangle
        @param dest: return location for the intersection of @src1 and @src2, or %NULL
        @type src2: Rectangle
        @type dest: Rectangle
        @returns: %TRUE if the rectangles intersect.
        @rtype: bool
        """
        return object
    
    def union(self, src2=None, dest=None):
        """        Calculates the union of two rectangles.
        The union of rectangles @src1 and @src2 is the smallest rectangle which
        includes both @src1 and @src2 within it.
        It is allowed for @dest to be the same as either @src1 or @src2.
        
        Note that this function does not ignore 'empty' rectangles (ie. with
        zero width or height).
        @param src2: a #GdkRectangle
        @param dest: return location for the union of @src1 and @src2
        @type src2: Rectangle
        @type dest: Rectangle
        @returns: 
        @rtype: None
        """
        return object

    @property
    def x(self):
        return object

    @property
    def y(self):
        return object

    @property
    def width(self):
        return object

    @property
    def height(self):
        return object


class Screen(GObject.Object):
    """#GdkScreen objects are the GDK representation of the screen on
which windows can be displayed and on which the pointer moves.
X originally identified screens with physical screens, but
nowadays it is more common to have a single #GdkScreen which
combines several physical monitors (see gdk_screen_get_n_monitors()).

GdkScreen is used throughout GDK and GTK+ to specify which screen
the top level windows are to be displayed on. it is also used to
query the screen specification and default settings such as
the default visual (gdk_screen_get_system_visual()), the dimensions
of the physical monitors (gdk_screen_get_monitor_geometry()), etc."""
    @staticmethod
    def get_default():
        """        Gets the default screen for the default display. (See
        gdk_display_get_default ()).
        @returns: a #GdkScreen, or %NULL if
     there is no default display.
        @rtype: Screen
        """
        return object
    @staticmethod
    def height():
        """        Gets the height of the default screen in pixels. The returned
        size is in ”application pixels”, not in ”device pixels” (see
        gdk_screen_get_monitor_scale_factor()).
        @returns: the height of the default screen in pixels.
        @rtype: int
        """
        return object
    @staticmethod
    def height_mm():
        """        Returns the height of the default screen in millimeters.
        Note that on many X servers this value will not be correct.
        @returns: the height of the default screen in millimeters, though it is not always correct.
        @rtype: int
        """
        return object
    @staticmethod
    def width():
        """        Gets the width of the default screen in pixels. The returned
        size is in ”application pixels”, not in ”device pixels” (see
        gdk_screen_get_monitor_scale_factor()).
        @returns: the width of the default screen in pixels.
        @rtype: int
        """
        return object
    @staticmethod
    def width_mm():
        """        Returns the width of the default screen in millimeters.
        Note that on many X servers this value will not be correct.
        @returns: the width of the default screen in millimeters, though it is not always correct.
        @rtype: int
        """
        return object
    
    def get_active_window(self):
        """        Returns the screen’s currently active window.
        
        On X11, this is done by inspecting the _NET_ACTIVE_WINDOW property
        on the root window, as described in the
        [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec).
        If there is no currently currently active
        window, or the window manager does not support the
        _NET_ACTIVE_WINDOW hint, this function returns %NULL.
        
        On other platforms, this function may return %NULL, depending on whether
        it is implementable on that platform.
        
        The returned window should be unrefed using g_object_unref() when
        no longer needed.
        @returns: the currently active window,
   or %NULL.
        @rtype: Window
        """
        return object
    
    def get_display(self):
        """        Gets the display to which the @screen belongs.
        @returns: the display to which @screen belongs
        @rtype: Display
        """
        return object
    
    def get_font_options(self):
        """        Gets any options previously set with gdk_screen_set_font_options().
        @returns: the current font options, or %NULL if no  default font options have been set.
        @rtype: cairo.FontOptions
        """
        return object
    
    def get_height(self):
        """        Gets the height of @screen in pixels. The returned size is in
        ”application pixels”, not in ”device pixels” (see
        gdk_screen_get_monitor_scale_factor()).
        @returns: the height of @screen in pixels.
        @rtype: int
        """
        return object
    
    def get_height_mm(self):
        """        Returns the height of @screen in millimeters.
        
        Note that this value is somewhat ill-defined when the screen
        has multiple monitors of different resolution. It is recommended
        to use the monitor dimensions instead.
        @returns: the heigth of @screen in millimeters.
        @rtype: int
        """
        return object
    
    def get_monitor_at_point(self, x=None, y=None):
        """        Returns the monitor number in which the point (@x,@y) is located.
        @param x: the x coordinate in the virtual screen.
        @param y: the y coordinate in the virtual screen.
        @type x: int
        @type y: int
        @returns: the monitor number in which the point (@x,@y) lies, or
   a monitor close to (@x,@y) if the point is not in any monitor.
        @rtype: int
        """
        return object
    
    def get_monitor_at_window(self, window=None):
        """        Returns the number of the monitor in which the largest area of the
        bounding rectangle of @window resides.
        @param window: a #GdkWindow
        @type window: Window
        @returns: the monitor number in which most of @window is located,
     or if @window does not intersect any monitors, a monitor,
     close to @window.
        @rtype: int
        """
        return object
    
    def get_monitor_geometry(self, monitor_num=None, dest=None):
        """        Retrieves the #GdkRectangle representing the size and position of
        the individual monitor within the entire screen area. The returned
        geometry is in ”application pixels”, not in ”device pixels” (see
        gdk_screen_get_monitor_scale_factor()).
        
        Monitor numbers start at 0. To obtain the number of monitors of
        @screen, use gdk_screen_get_n_monitors().
        
        Note that the size of the entire screen area can be retrieved via
        gdk_screen_get_width() and gdk_screen_get_height().
        @param monitor_num: the monitor number
        @param dest: a #GdkRectangle to be filled with     the monitor geometry
        @type monitor_num: int
        @type dest: Rectangle
        @returns: 
        @rtype: None
        """
        return object
    
    def get_monitor_height_mm(self, monitor_num=None):
        """        Gets the height in millimeters of the specified monitor.
        @param monitor_num: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen)
        @type monitor_num: int
        @returns: the height of the monitor, or -1 if not available
        @rtype: int
        """
        return object
    
    def get_monitor_plug_name(self, monitor_num=None):
        """        Returns the output name of the specified monitor.
        Usually something like VGA, DVI, or TV, not the actual
        product name of the display device.
        @param monitor_num: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen)
        @type monitor_num: int
        @returns: a newly-allocated string containing the name
   of the monitor, or %NULL if the name cannot be determined
        @rtype: str
        """
        return object
    
    def get_monitor_scale_factor(self, monitor_num=None):
        """        Returns the internal scale factor that maps from monitor coordinates
        to the actual device pixels. On traditional systems this is 1, but
        on very high density outputs this can be a higher value (often 2).
        
        This can be used if you want to create pixel based data for a
        particular monitor, but most of the time you’re drawing to a window
        where it is better to use gdk_window_get_scale_factor() instead.
        @param monitor_num: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen)
        @type monitor_num: int
        @returns: the scale factor
        @rtype: int
        """
        return object
    
    def get_monitor_width_mm(self, monitor_num=None):
        """        Gets the width in millimeters of the specified monitor, if available.
        @param monitor_num: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen)
        @type monitor_num: int
        @returns: the width of the monitor, or -1 if not available
        @rtype: int
        """
        return object
    
    def get_monitor_workarea(self, monitor_num=None, dest=None):
        """        Retrieves the #GdkRectangle representing the size and position of
        the “work area” on a monitor within the entire screen area. The returned
        geometry is in ”application pixels”, not in ”device pixels” (see
        gdk_screen_get_monitor_scale_factor()).
        
        The work area should be considered when positioning menus and
        similar popups, to avoid placing them below panels, docks or other
        desktop components.
        
        Note that not all backends may have a concept of workarea. This
        function will return the monitor geometry if a workarea is not
        available, or does not apply.
        
        Monitor numbers start at 0. To obtain the number of monitors of
        @screen, use gdk_screen_get_n_monitors().
        @param monitor_num: the monitor number
        @param dest: a #GdkRectangle to be filled with     the monitor workarea
        @type monitor_num: int
        @type dest: Rectangle
        @returns: 
        @rtype: None
        """
        return object
    
    def get_n_monitors(self):
        """        Returns the number of monitors which @screen consists of.
        @returns: number of monitors which @screen consists of
        @rtype: int
        """
        return object
    
    def get_number(self):
        """        Gets the index of @screen among the screens in the display
        to which it belongs. (See gdk_screen_get_display())
        @returns: the index
        @rtype: int
        """
        return object
    
    def get_primary_monitor(self):
        """        Gets the primary monitor for @screen.  The primary monitor
        is considered the monitor where the “main desktop” lives.
        While normal application windows typically allow the window
        manager to place the windows, specialized desktop applications
        such as panels should place themselves on the primary monitor.
        
        If no primary monitor is configured by the user, the return value
        will be 0, defaulting to the first monitor.
        @returns: An integer index for the primary monitor, or 0 if none is configured.
        @rtype: int
        """
        return object
    
    def get_resolution(self):
        """        Gets the resolution for font handling on the screen; see
        gdk_screen_set_resolution() for full details.
        @returns: the current resolution, or -1 if no resolution has been set.
        @rtype: float
        """
        return object
    
    def get_rgba_visual(self):
        """        Gets a visual to use for creating windows with an alpha channel.
        The windowing system on which GTK+ is running
        may not support this capability, in which case %NULL will
        be returned. Even if a non-%NULL value is returned, its
        possible that the window’s alpha channel won’t be honored
        when displaying the window on the screen: in particular, for
        X an appropriate windowing manager and compositing manager
        must be running to provide appropriate display.
        
        This functionality is not implemented in the Windows backend.
        
        For setting an overall opacity for a top-level window, see
        gdk_window_set_opacity().
        @returns: a visual to use for windows
     with an alpha channel or %NULL if the capability is not
     available.
        @rtype: Visual
        """
        return object
    
    def get_root_window(self):
        """        Gets the root window of @screen.
        @returns: the root window
        @rtype: Window
        """
        return object
    
    def get_setting(self, name=None, value=None):
        """        Retrieves a desktop-wide setting such as double-click time
        for the #GdkScreen @screen.
        
        FIXME needs a list of valid settings here, or a link to
        more information.
        @param name: the name of the setting
        @param value: location to store the value of the setting
        @type name: str
        @type value: GObject.Value
        @returns: %TRUE if the setting existed and a value was stored
   in @value, %FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def get_system_visual(self):
        """        Get the system’s default visual for @screen.
        This is the visual for the root window of the display.
        The return value should not be freed.
        @returns: the system visual
        @rtype: Visual
        """
        return object
    
    def get_toplevel_windows(self):
        """        Obtains a list of all toplevel windows known to GDK on the screen @screen.
        A toplevel window is a child of the root window (see
        gdk_get_default_root_window()).
        
        The returned list should be freed with g_list_free(), but
        its elements need not be freed.
        @returns: list of toplevel windows, free with g_list_free()
        @rtype: GLib.List
        """
        return object
    
    def get_width(self):
        """        Gets the width of @screen in pixels. The returned size is in
        ”application pixels”, not in ”device pixels” (see
        gdk_screen_get_monitor_scale_factor()).
        @returns: the width of @screen in pixels.
        @rtype: int
        """
        return object
    
    def get_width_mm(self):
        """        Gets the width of @screen in millimeters.
        
        Note that this value is somewhat ill-defined when the screen
        has multiple monitors of different resolution. It is recommended
        to use the monitor dimensions instead.
        @returns: the width of @screen in millimeters.
        @rtype: int
        """
        return object
    
    def get_window_stack(self):
        """        Returns a #GList of #GdkWindows representing the current
        window stack.
        
        On X11, this is done by inspecting the _NET_CLIENT_LIST_STACKING
        property on the root window, as described in the
        [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec).
        If the window manager does not support the
        _NET_CLIENT_LIST_STACKING hint, this function returns %NULL.
        
        On other platforms, this function may return %NULL, depending on whether
        it is implementable on that platform.
        
        The returned list is newly allocated and owns references to the
        windows it contains, so it should be freed using g_list_free() and
        its windows unrefed using g_object_unref() when no longer needed.
        @returns: a
     list of #GdkWindows for the current window stack, or %NULL.
        @rtype: GLib.List
        """
        return object
    
    def is_composited(self):
        """        Returns whether windows with an RGBA visual can reasonably
        be expected to have their alpha channel drawn correctly on
        the screen.
        
        On X11 this function returns whether a compositing manager is
        compositing @screen.
        @returns: Whether windows with RGBA visuals can reasonably be expected to have their alpha channels drawn correctly on the screen.
        @rtype: bool
        """
        return object
    
    def list_visuals(self):
        """        Lists the available visuals for the specified @screen.
        A visual describes a hardware image data format.
        For example, a visual might support 24-bit color, or 8-bit color,
        and might expect pixels to be in a certain format.
        
        Call g_list_free() on the return value when you’re finished with it.
        @returns: a list of visuals; the list must be freed, but not its contents
        @rtype: GLib.List
        """
        return object
    
    def make_display_name(self):
        """        Determines the name to pass to gdk_display_open() to get
        a #GdkDisplay with this screen as the default screen.
        @returns: a newly allocated string, free with g_free()
        @rtype: str
        """
        return object
    
    def set_font_options(self, options=None):
        """        Sets the default font options for the screen. These
        options will be set on any #PangoContext’s newly created
        with gdk_pango_context_get_for_screen(). Changing the
        default set of font options does not affect contexts that
        have already been created.
        @param options: a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
        @type options: cairo.FontOptions
        @returns: 
        @rtype: None
        """
        return object
    
    def set_resolution(self, dpi=None):
        """        Sets the resolution for font handling on the screen. This is a
        scale factor between points specified in a #PangoFontDescription
        and cairo units. The default value is 96, meaning that a 10 point
        font will be 13 units high. (10 * 96. / 72. = 13.3).
        @param dpi: the resolution in “dots per inch”. (Physical inches aren’t actually   involved; the terminology is conventional.)
        @type dpi: float
        @returns: 
        @rtype: None
        """
        return object


class Seat(GObject.Object):
    """The #GdkSeat object represents a collection of input devices
that belong to a user."""
    
    def get_capabilities(self):
        """        Returns the capabilities this #GdkSeat currently has.
        @returns: the seat capabilities
        @rtype: SeatCapabilities
        """
        return object
    
    def get_display(self):
        """        Returns the #GdkDisplay this seat belongs to.
        @returns: a #GdkDisplay. This object is owned by GTK+
          and must not be freed.
        @rtype: Display
        """
        return object
    
    def get_keyboard(self):
        """        Returns the master device that routes keyboard events.
        @returns: a master #GdkDevice with keyboard
          capabilities. This object is owned by GTK+ and must not be freed.
        @rtype: Device
        """
        return object
    
    def get_pointer(self):
        """        Returns the master device that routes pointer events.
        @returns: a master #GdkDevice with pointer
          capabilities. This object is owned by GTK+ and must not be freed.
        @rtype: Device
        """
        return object
    
    def get_slaves(self, capabilities=None):
        """        Returns the slave devices that match the given capabilities.
        @param capabilities: capabilities to get devices for
        @type capabilities: SeatCapabilities
        @returns: A list of #GdkDevices.
          The list must be freed with g_list_free(), the elements are owned
          by GDK and must not be freed.
        @rtype: GLib.List
        """
        return object
    
    def grab(self, window=None, capabilities=None, owner_events=None, cursor=None, event=None, prepare_func=None, prepare_func_data=None):
        """        Grabs the seat so that all events corresponding to the given @capabilities
        are passed to this application until the seat is ungrabbed with gdk_seat_ungrab(),
        or the window becomes hidden. This overrides any previous grab on the
        seat by this client.
        
        As a rule of thumb, if a grab is desired over %GDK_SEAT_CAPABILITY_POINTER,
        all other "pointing" capabilities (eg. %GDK_SEAT_CAPABILITY_TOUCH) should
        be grabbed too, so the user is able to interact with all of those while
        the grab holds, you should thus use %GDK_SEAT_CAPABILITY_ALL_POINTING most
        commonly.
        
        Grabs are used for operations which need complete control over the
        events corresponding to the given capabilities. For example in GTK+ this
        is used for Drag and Drop operations, popup menus and such.
        
        Note that if the event mask of a #GdkWindow has selected both button press
        and button release events, or touch begin and touch end, then a press event
        will cause an automatic grab until the button is released, equivalent to a
        grab on the window with @owner_events set to %TRUE. This is done because most
        applications expect to receive paired press and release events.
        
        If you set up anything at the time you take the grab that needs to be
        cleaned up when the grab ends, you should handle the #GdkEventGrabBroken
        events that are emitted when the grab ends unvoluntarily.
        @param window: the #GdkWindow which will own the grab
        @param capabilities: capabilities that will be grabbed
        @param owner_events: if %FALSE then all device events are reported with respect to                @window and are only reported if selected by @event_mask. If                %TRUE then pointer events for this application are reported                as normal, but pointer events outside this application are                reported with respect to @window and only if selected by                @event_mask. In either mode, unreported events are discarded.
        @param cursor: the cursor to display while the grab is active. If          this is %NULL then the normal cursors are used for          @window and its descendants, and the cursor for @window is used          elsewhere.
        @param event: the event that is triggering the grab, or %NULL if none         is available.
        @param prepare_func: function to                prepare the window to be grabbed, it can be %NULL if @window is                visible before this call.
        @param prepare_func_data: user data to pass to @prepare_func
        @type window: Window
        @type capabilities: SeatCapabilities
        @type owner_events: bool
        @type cursor: Cursor
        @type event: Event
        @type prepare_func: SeatGrabPrepareFunc
        @type prepare_func_data: gpointer
        @returns: %GDK_GRAB_SUCCESS if the grab was successful.
        @rtype: GrabStatus
        """
        return object
    
    def ungrab(self):
        """        Releases a grab added through gdk_seat_grab().
        @returns: 
        @rtype: None
        """
        return object

    @property
    def parent_instance(self):
        return object


class TimeCoord():
    """A #GdkTimeCoord stores a single event in a motion history."""

    @property
    def time(self):
        return object

    @property
    def axes(self):
        return object


class Visual(GObject.Object):
    """A #GdkVisual contains information about
a particular visual."""
    @staticmethod
    def get_best():
        """        Get the visual with the most available colors for the default
        GDK screen. The return value should not be freed.
        @returns: best visual
        @rtype: Visual
        """
        return object
    @staticmethod
    def get_best_depth():
        """        Get the best available depth for the default GDK screen.  “Best”
        means “largest,” i.e. 32 preferred over 24 preferred over 8 bits
        per pixel.
        @returns: best available depth
        @rtype: int
        """
        return object
    @staticmethod
    def get_best_type():
        """        Return the best available visual type for the default GDK screen.
        @returns: best visual type
        @rtype: VisualType
        """
        return object
    @staticmethod
    def get_best_with_both(depth=None, visual_type=None):
        """        Combines gdk_visual_get_best_with_depth() and
        gdk_visual_get_best_with_type().
        @param depth: a bit depth
        @param visual_type: a visual type
        @type depth: int
        @type visual_type: VisualType
        @returns: best visual with both @depth
     and @visual_type, or %NULL if none
        @rtype: Visual
        """
        return object
    @staticmethod
    def get_best_with_depth(depth=None):
        """        Get the best visual with depth @depth for the default GDK screen.
        Color visuals and visuals with mutable colormaps are preferred
        over grayscale or fixed-colormap visuals. The return value should
        not be freed. %NULL may be returned if no visual supports @depth.
        @param depth: a bit depth
        @type depth: int
        @returns: best visual for the given depth
        @rtype: Visual
        """
        return object
    @staticmethod
    def get_best_with_type(visual_type=None):
        """        Get the best visual of the given @visual_type for the default GDK screen.
        Visuals with higher color depths are considered better. The return value
        should not be freed. %NULL may be returned if no visual has type
        @visual_type.
        @param visual_type: a visual type
        @type visual_type: VisualType
        @returns: best visual of the given type
        @rtype: Visual
        """
        return object
    @staticmethod
    def get_system():
        """        Get the system’s default visual for the default GDK screen.
        This is the visual for the root window of the display.
        The return value should not be freed.
        @returns: system visual
        @rtype: Visual
        """
        return object
    
    def get_bits_per_rgb(self):
        """        Returns the number of significant bits per red, green and blue value.
        
        Not all GDK backend provide a meaningful value for this function.
        @returns: The number of significant bits per color value for @visual.
        @rtype: int
        """
        return object
    
    def get_blue_pixel_details(self, mask=None, shift=None, precision=None):
        """        Obtains values that are needed to calculate blue pixel values in TrueColor
        and DirectColor. The “mask” is the significant bits within the pixel.
        The “shift” is the number of bits left we must shift a primary for it
        to be in position (according to the "mask"). Finally, "precision" refers
        to how much precision the pixel value contains for a particular primary.
        @param mask: A pointer to a #guint32 to be filled in, or %NULL
        @param shift: A pointer to a #gint to be filled in, or %NULL
        @param precision: A pointer to a #gint to be filled in, or %NULL
        @type mask: guint32
        @type shift: int
        @type precision: int
        @returns: 
        @rtype: None
        """
        return object
    
    def get_byte_order(self):
        """        Returns the byte order of this visual.
        
        The information returned by this function is only relevant
        when working with XImages, and not all backends return
        meaningful information for this.
        @returns: A #GdkByteOrder stating the byte order of @visual.
        @rtype: ByteOrder
        """
        return object
    
    def get_colormap_size(self):
        """        Returns the size of a colormap for this visual.
        
        You have to use platform-specific APIs to manipulate colormaps.
        @returns: The size of a colormap that is suitable for @visual.
        @rtype: int
        """
        return object
    
    def get_depth(self):
        """        Returns the bit depth of this visual.
        @returns: The bit depth of this visual.
        @rtype: int
        """
        return object
    
    def get_green_pixel_details(self, mask=None, shift=None, precision=None):
        """        Obtains values that are needed to calculate green pixel values in TrueColor
        and DirectColor. The “mask” is the significant bits within the pixel.
        The “shift” is the number of bits left we must shift a primary for it
        to be in position (according to the "mask"). Finally, "precision" refers
        to how much precision the pixel value contains for a particular primary.
        @param mask: A pointer to a #guint32 to be filled in, or %NULL
        @param shift: A pointer to a #gint to be filled in, or %NULL
        @param precision: A pointer to a #gint to be filled in, or %NULL
        @type mask: guint32
        @type shift: int
        @type precision: int
        @returns: 
        @rtype: None
        """
        return object
    
    def get_red_pixel_details(self, mask=None, shift=None, precision=None):
        """        Obtains values that are needed to calculate red pixel values in TrueColor
        and DirectColor. The “mask” is the significant bits within the pixel.
        The “shift” is the number of bits left we must shift a primary for it
        to be in position (according to the "mask"). Finally, "precision" refers
        to how much precision the pixel value contains for a particular primary.
        @param mask: A pointer to a #guint32 to be filled in, or %NULL
        @param shift: A pointer to a #gint to be filled in, or %NULL
        @param precision: A pointer to a #gint to be filled in, or %NULL
        @type mask: guint32
        @type shift: int
        @type precision: int
        @returns: 
        @rtype: None
        """
        return object
    
    def get_screen(self):
        """        Gets the screen to which this visual belongs
        @returns: the screen to which this visual belongs.
        @rtype: Screen
        """
        return object
    
    def get_visual_type(self):
        """        Returns the type of visual this is (PseudoColor, TrueColor, etc).
        @returns: A #GdkVisualType stating the type of @visual.
        @rtype: VisualType
        """
        return object


class Window(GObject.Object):
    """"""
    
    def __init__(self, parent=None, attributes=None, attributes_mask=None):
        """        Creates a new #GdkWindow using the attributes from
        @attributes. See #GdkWindowAttr and #GdkWindowAttributesType for
        more details.  Note: to use this on displays other than the default
        display, @parent must be specified.
        @param parent: a #GdkWindow, or %NULL to create the window as a child of   the default root window for the default display.
        @param attributes: attributes of the new window
        @param attributes_mask: mask indicating which   fields in @attributes are valid
        @type parent: Window
        @type attributes: WindowAttr
        @type attributes_mask: WindowAttributesType
        @returns: Newly created Window
        @rtype: Window
        """
        return object
    @staticmethod
    def new(parent=None, attributes=None, attributes_mask=None):
        """        Creates a new #GdkWindow using the attributes from
        @attributes. See #GdkWindowAttr and #GdkWindowAttributesType for
        more details.  Note: to use this on displays other than the default
        display, @parent must be specified.
        @param parent: a #GdkWindow, or %NULL to create the window as a child of   the default root window for the default display.
        @param attributes: attributes of the new window
        @param attributes_mask: mask indicating which   fields in @attributes are valid
        @type parent: Window
        @type attributes: WindowAttr
        @type attributes_mask: WindowAttributesType
        @returns: Newly created Window
        @rtype: Window
        """
        return object
    @staticmethod
    def at_pointer(win_x=None, win_y=None):
        """        Obtains the window underneath the mouse pointer, returning the
        location of that window in @win_x, @win_y. Returns %NULL if the
        window under the mouse pointer is not known to GDK (if the window
        belongs to another application and a #GdkWindow hasn’t been created
        for it with gdk_window_foreign_new())
        
        NOTE: For multihead-aware widgets or applications use
        gdk_display_get_window_at_pointer() instead.
        @param win_x: return location for origin of the window under the pointer
        @param win_y: return location for origin of the window under the pointer
        @type win_x: int
        @type win_y: int
        @returns: window under the mouse pointer
        @rtype: Window
        """
        return object
    @staticmethod
    def constrain_size(geometry=None, flags=None, width=None, height=None, new_width=None, new_height=None):
        """        Constrains a desired width and height according to a
        set of geometry hints (such as minimum and maximum size).
        @param geometry: a #GdkGeometry structure
        @param flags: a mask indicating what portions of @geometry are set
        @param width: desired width of window
        @param height: desired height of the window
        @param new_width: location to store resulting width
        @param new_height: location to store resulting height
        @type geometry: Geometry
        @type flags: WindowHints
        @type width: int
        @type height: int
        @type new_width: int
        @type new_height: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def process_all_updates():
        """        Calls gdk_window_process_updates() for all windows (see #GdkWindow)
        in the application.
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def set_debug_updates(setting=None):
        """        With update debugging enabled, calls to
        gdk_window_invalidate_region() clear the invalidated region of the
        screen to a noticeable color, and GDK pauses for a short time
        before sending exposes to windows during
        gdk_window_process_updates().  The net effect is that you can see
        the invalid region for each window and watch redraws as they
        occur. This allows you to diagnose inefficiencies in your application.
        
        In essence, because the GDK rendering model prevents all flicker,
        if you are redrawing the same region 400 times you may never
        notice, aside from noticing a speed problem. Enabling update
        debugging causes GTK to flicker slowly and noticeably, so you can
        see exactly what’s being redrawn when, in what order.
        
        The --gtk-debug=updates command line option passed to GTK+ programs
        enables this debug option at application startup time. That's
        usually more useful than calling gdk_window_set_debug_updates()
        yourself, though you might want to use this function to enable
        updates sometime after application startup time.
        @param setting: %TRUE to turn on update debugging
        @type setting: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def create_surface(self, width=None, height=None):
        """        
        @type width: int
        @type height: int
        @returns: 
        @rtype: cairo.Surface
        """
        return object
    
    def from_embedder(self, embedder_x=None, embedder_y=None, offscreen_x=None, offscreen_y=None):
        """        
        @type embedder_x: float
        @type embedder_y: float
        @type offscreen_x: float
        @type offscreen_y: float
        @returns: 
        @rtype: None
        """
        return object
    
    def pick_embedded_child(self, x=None, y=None):
        """        
        @type x: float
        @type y: float
        @returns: 
        @rtype: Window
        """
        return object
    
    def to_embedder(self, offscreen_x=None, offscreen_y=None, embedder_x=None, embedder_y=None):
        """        
        @type offscreen_x: float
        @type offscreen_y: float
        @type embedder_x: float
        @type embedder_y: float
        @returns: 
        @rtype: None
        """
        return object
    
    def add_filter(self, function=None, data=None):
        """        Adds an event filter to @window, allowing you to intercept events
        before they reach GDK. This is a low-level operation and makes it
        easy to break GDK and/or GTK+, so you have to know what you're
        doing. Pass %NULL for @window to get all events for all windows,
        instead of events for a specific window.
        
        If you are interested in X GenericEvents, bear in mind that
        XGetEventData() has been already called on the event, and
        XFreeEventData() must not be called within @function.
        @param function: filter callback
        @param data: data to pass to filter callback
        @type function: FilterFunc
        @type data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def beep(self):
        """        Emits a short beep associated to @window in the appropriate
        display, if supported. Otherwise, emits a short beep on
        the display just as gdk_display_beep().
        @returns: 
        @rtype: None
        """
        return object
    
    def begin_draw_frame(self, region=None):
        """        Indicates that you are beginning the process of redrawing @region
        on @window, and provides you with a #GdkDrawingContext.
        
        If @window is a top level #GdkWindow, backed by a native window
        implementation, a backing store (offscreen buffer) large enough to
        contain @region will be created. The backing store will be initialized
        with the background color or background surface for @window. Then, all
        drawing operations performed on @window will be diverted to the
        backing store. When you call gdk_window_end_frame(), the contents of
        the backing store will be copied to @window, making it visible
        on screen. Only the part of @window contained in @region will be
        modified; that is, drawing operations are clipped to @region.
        
        The net result of all this is to remove flicker, because the user
        sees the finished product appear all at once when you call
        gdk_window_end_draw_frame(). If you draw to @window directly without
        calling gdk_window_begin_draw_frame(), the user may see flicker
        as individual drawing operations are performed in sequence.
        
        When using GTK+, the widget system automatically places calls to
        gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() around
        emissions of the `GtkWidget::draw` signal. That is, if you’re
        drawing the contents of the widget yourself, you can assume that the
        widget has a cleared background, is already set as the clip region,
        and already has a backing store. Therefore in most cases, application
        code in GTK does not need to call gdk_window_begin_draw_frame()
        explicitly.
        @param region: a Cairo region
        @type region: cairo.Region
        @returns: a #GdkDrawingContext context that should be
   used to draw the contents of the window; the returned context is owned
   by GDK.
        @rtype: DrawingContext
        """
        return object
    
    def begin_move_drag(self, button=None, root_x=None, root_y=None, timestamp=None):
        """        Begins a window move operation (for a toplevel window).
        
        This function assumes that the drag is controlled by the
        client pointer device, use gdk_window_begin_move_drag_for_device()
        to begin a drag with a different device.
        @param button: the button being used to drag, or 0 for a keyboard-initiated drag
        @param root_x: root window X coordinate of mouse click that began the drag
        @param root_y: root window Y coordinate of mouse click that began the drag
        @param timestamp: timestamp of mouse click that began the drag
        @type button: int
        @type root_x: int
        @type root_y: int
        @type timestamp: guint32
        @returns: 
        @rtype: None
        """
        return object
    
    def begin_move_drag_for_device(self, device=None, button=None, root_x=None, root_y=None, timestamp=None):
        """        Begins a window move operation (for a toplevel window).
        You might use this function to implement a “window move grip,” for
        example. The function works best with window managers that support the
        [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
        but has a fallback implementation for other window managers.
        @param device: the device used for the operation
        @param button: the button being used to drag, or 0 for a keyboard-initiated drag
        @param root_x: root window X coordinate of mouse click that began the drag
        @param root_y: root window Y coordinate of mouse click that began the drag
        @param timestamp: timestamp of mouse click that began the drag
        @type device: Device
        @type button: int
        @type root_x: int
        @type root_y: int
        @type timestamp: guint32
        @returns: 
        @rtype: None
        """
        return object
    
    def begin_paint_rect(self, rectangle=None):
        """        A convenience wrapper around gdk_window_begin_paint_region() which
        creates a rectangular region for you. See
        gdk_window_begin_paint_region() for details.
        @param rectangle: rectangle you intend to draw to
        @type rectangle: Rectangle
        @returns: 
        @rtype: None
        """
        return object
    
    def begin_paint_region(self, region=None):
        """        Indicates that you are beginning the process of redrawing @region.
        A backing store (offscreen buffer) large enough to contain @region
        will be created. The backing store will be initialized with the
        background color or background surface for @window. Then, all
        drawing operations performed on @window will be diverted to the
        backing store.  When you call gdk_window_end_paint(), the backing
        store will be copied to @window, making it visible onscreen. Only
        the part of @window contained in @region will be modified; that is,
        drawing operations are clipped to @region.
        
        The net result of all this is to remove flicker, because the user
        sees the finished product appear all at once when you call
        gdk_window_end_paint(). If you draw to @window directly without
        calling gdk_window_begin_paint_region(), the user may see flicker
        as individual drawing operations are performed in sequence.  The
        clipping and background-initializing features of
        gdk_window_begin_paint_region() are conveniences for the
        programmer, so you can avoid doing that work yourself.
        
        When using GTK+, the widget system automatically places calls to
        gdk_window_begin_paint_region() and gdk_window_end_paint() around
        emissions of the expose_event signal. That is, if you’re writing an
        expose event handler, you can assume that the exposed area in
        #GdkEventExpose has already been cleared to the window background,
        is already set as the clip region, and already has a backing store.
        Therefore in most cases, application code need not call
        gdk_window_begin_paint_region(). (You can disable the automatic
        calls around expose events on a widget-by-widget basis by calling
        gtk_widget_set_double_buffered().)
        
        If you call this function multiple times before calling the
        matching gdk_window_end_paint(), the backing stores are pushed onto
        a stack. gdk_window_end_paint() copies the topmost backing store
        onscreen, subtracts the topmost region from all other regions in
        the stack, and pops the stack. All drawing operations affect only
        the topmost backing store in the stack. One matching call to
        gdk_window_end_paint() is required for each call to
        gdk_window_begin_paint_region().
        @param region: region you intend to draw to
        @type region: cairo.Region
        @returns: 
        @rtype: None
        """
        return object
    
    def begin_resize_drag(self, edge=None, button=None, root_x=None, root_y=None, timestamp=None):
        """        Begins a window resize operation (for a toplevel window).
        
        This function assumes that the drag is controlled by the
        client pointer device, use gdk_window_begin_resize_drag_for_device()
        to begin a drag with a different device.
        @param edge: the edge or corner from which the drag is started
        @param button: the button being used to drag, or 0 for a keyboard-initiated drag
        @param root_x: root window X coordinate of mouse click that began the drag
        @param root_y: root window Y coordinate of mouse click that began the drag
        @param timestamp: timestamp of mouse click that began the drag (use gdk_event_get_time())
        @type edge: WindowEdge
        @type button: int
        @type root_x: int
        @type root_y: int
        @type timestamp: guint32
        @returns: 
        @rtype: None
        """
        return object
    
    def begin_resize_drag_for_device(self, edge=None, device=None, button=None, root_x=None, root_y=None, timestamp=None):
        """        Begins a window resize operation (for a toplevel window).
        You might use this function to implement a “window resize grip,” for
        example; in fact #GtkStatusbar uses it. The function works best
        with window managers that support the
        [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
        but has a fallback implementation for other window managers.
        @param edge: the edge or corner from which the drag is started
        @param device: the device used for the operation
        @param button: the button being used to drag, or 0 for a keyboard-initiated drag
        @param root_x: root window X coordinate of mouse click that began the drag
        @param root_y: root window Y coordinate of mouse click that began the drag
        @param timestamp: timestamp of mouse click that began the drag (use gdk_event_get_time())
        @type edge: WindowEdge
        @type device: Device
        @type button: int
        @type root_x: int
        @type root_y: int
        @type timestamp: guint32
        @returns: 
        @rtype: None
        """
        return object
    
    def configure_finished(self):
        """        Does nothing, present only for compatiblity.
        @returns: 
        @rtype: None
        """
        return object
    
    def coords_from_parent(self, parent_x=None, parent_y=None, x=None, y=None):
        """        Transforms window coordinates from a parent window to a child
        window, where the parent window is the normal parent as returned by
        gdk_window_get_parent() for normal windows, and the window's
        embedder as returned by gdk_offscreen_window_get_embedder() for
        offscreen windows.
        
        For normal windows, calling this function is equivalent to subtracting
        the return values of gdk_window_get_position() from the parent coordinates.
        For offscreen windows however (which can be arbitrarily transformed),
        this function calls the GdkWindow::from-embedder: signal to translate
        the coordinates.
        
        You should always use this function when writing generic code that
        walks down a window hierarchy.
        
        See also: gdk_window_coords_to_parent()
        @param parent_x: X coordinate in parent’s coordinate system
        @param parent_y: Y coordinate in parent’s coordinate system
        @param x: return location for X coordinate in child’s coordinate system
        @param y: return location for Y coordinate in child’s coordinate system
        @type parent_x: float
        @type parent_y: float
        @type x: float
        @type y: float
        @returns: 
        @rtype: None
        """
        return object
    
    def coords_to_parent(self, x=None, y=None, parent_x=None, parent_y=None):
        """        Transforms window coordinates from a child window to its parent
        window, where the parent window is the normal parent as returned by
        gdk_window_get_parent() for normal windows, and the window's
        embedder as returned by gdk_offscreen_window_get_embedder() for
        offscreen windows.
        
        For normal windows, calling this function is equivalent to adding
        the return values of gdk_window_get_position() to the child coordinates.
        For offscreen windows however (which can be arbitrarily transformed),
        this function calls the GdkWindow::to-embedder: signal to translate
        the coordinates.
        
        You should always use this function when writing generic code that
        walks up a window hierarchy.
        
        See also: gdk_window_coords_from_parent()
        @param x: X coordinate in child’s coordinate system
        @param y: Y coordinate in child’s coordinate system
        @param parent_x: return location for X coordinate in parent’s coordinate system, or %NULL
        @param parent_y: return location for Y coordinate in parent’s coordinate system, or %NULL
        @type x: float
        @type y: float
        @type parent_x: float
        @type parent_y: float
        @returns: 
        @rtype: None
        """
        return object
    
    def create_gl_context(self):
        """        Creates a new #GdkGLContext matching the
        framebuffer format to the visual of the #GdkWindow. The context
        is disconnected from any particular window or surface.
        
        If the creation of the #GdkGLContext failed, @error will be set.
        
        Before using the returned #GdkGLContext, you will need to
        call gdk_gl_context_make_current() or gdk_gl_context_realize().
        @returns: the newly created #GdkGLContext, or %NULL on error
        @rtype: GLContext
        """
        return object
    
    def create_similar_image_surface(self, format=None, width=None, height=None, scale=None):
        """        Create a new image surface that is efficient to draw on the
        given @window.
        
        Initially the surface contents are all 0 (transparent if contents
        have transparency, black otherwise.)
        
        The @width and @height of the new surface are not affected by
        the scaling factor of the @window, or by the @scale argument; they
        are the size of the surface in device pixels. If you wish to create
        an image surface capable of holding the contents of @window you can
        use:
        
        |[<!-- language="C" -->
          int scale = gdk_window_get_scale_factor (window);
          int width = gdk_window_get_width (window) * scale;
          int height = gdk_window_get_height (window) * scale;
        
          // format is set elsewhere
          cairo_surface_t *surface =
            gdk_window_create_similar_image_surface (window,
                                                     format,
                                                     width, height,
                                                     scale);
        ]|
        
        Note that unlike cairo_surface_create_similar_image(), the new
        surface's device scale is set to @scale, or to the scale factor of
        @window if @scale is 0.
        @param format: the format for the new surface
        @param width: width of the new surface
        @param height: height of the new surface
        @param scale: the scale of the new surface, or 0 to use same as @window
        @type format: int
        @type width: int
        @type height: int
        @type scale: int
        @returns: a pointer to the newly allocated surface. The caller owns the surface and should call cairo_surface_destroy() when done with it.  This function always returns a valid pointer, but it will return a pointer to a “nil” surface if @other is already in an error state or any other error occurs.
        @rtype: cairo.Surface
        """
        return object
    
    def create_similar_surface(self, content=None, width=None, height=None):
        """        Create a new surface that is as compatible as possible with the
        given @window. For example the new surface will have the same
        fallback resolution and font options as @window. Generally, the new
        surface will also use the same backend as @window, unless that is
        not possible for some reason. The type of the returned surface may
        be examined with cairo_surface_get_type().
        
        Initially the surface contents are all 0 (transparent if contents
        have transparency, black otherwise.)
        @param content: the content for the new surface
        @param width: width of the new surface
        @param height: height of the new surface
        @type content: cairo.Content
        @type width: int
        @type height: int
        @returns: a pointer to the newly allocated surface. The caller owns the surface and should call cairo_surface_destroy() when done with it.  This function always returns a valid pointer, but it will return a pointer to a “nil” surface if @other is already in an error state or any other error occurs.
        @rtype: cairo.Surface
        """
        return object
    
    def deiconify(self):
        """        Attempt to deiconify (unminimize) @window. On X11 the window manager may
        choose to ignore the request to deiconify. When using GTK+,
        use gtk_window_deiconify() instead of the #GdkWindow variant. Or better yet,
        you probably want to use gtk_window_present(), which raises the window, focuses it,
        unminimizes it, and puts it on the current desktop.
        @returns: 
        @rtype: None
        """
        return object
    
    def destroy(self):
        """        Destroys the window system resources associated with @window and decrements @window's
        reference count. The window system resources for all children of @window are also
        destroyed, but the children’s reference counts are not decremented.
        
        Note that a window will not be destroyed automatically when its reference count
        reaches zero. You must call this function yourself before that happens.
        @returns: 
        @rtype: None
        """
        return object
    
    def destroy_notify(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def enable_synchronized_configure(self):
        """        Does nothing, present only for compatiblity.
        @returns: 
        @rtype: None
        """
        return object
    
    def end_draw_frame(self, context=None):
        """        Indicates that the drawing of the contents of @window started with
        gdk_window_begin_frame() has been completed.
        
        This function will take care of destroying the #GdkDrawingContext.
        
        It is an error to call this function without a matching
        gdk_window_begin_frame() first.
        @param context: the #GdkDrawingContext created by gdk_window_begin_draw_frame()
        @type context: DrawingContext
        @returns: 
        @rtype: None
        """
        return object
    
    def end_paint(self):
        """        Indicates that the backing store created by the most recent call
        to gdk_window_begin_paint_region() should be copied onscreen and
        deleted, leaving the next-most-recent backing store or no backing
        store at all as the active paint region. See
        gdk_window_begin_paint_region() for full details.
        
        It is an error to call this function without a matching
        gdk_window_begin_paint_region() first.
        @returns: 
        @rtype: None
        """
        return object
    
    def ensure_native(self):
        """        Tries to ensure that there is a window-system native window for this
        GdkWindow. This may fail in some situations, returning %FALSE.
        
        Offscreen window and children of them can never have native windows.
        
        Some backends may not support native child windows.
        @returns: %TRUE if the window has a native window, %FALSE otherwise
        @rtype: bool
        """
        return object
    
    def flush(self):
        """        This function does nothing.
        @returns: 
        @rtype: None
        """
        return object
    
    def focus(self, timestamp=None):
        """        Sets keyboard focus to @window. In most cases, gtk_window_present()
        should be used on a #GtkWindow, rather than calling this function.
        @param timestamp: timestamp of the event triggering the window focus
        @type timestamp: guint32
        @returns: 
        @rtype: None
        """
        return object
    
    def freeze_toplevel_updates_libgtk_only(self):
        """        Temporarily freezes a window and all its descendants such that it won't
        receive expose events.  The window will begin receiving expose events
        again when gdk_window_thaw_toplevel_updates_libgtk_only() is called. If
        gdk_window_freeze_toplevel_updates_libgtk_only()
        has been called more than once,
        gdk_window_thaw_toplevel_updates_libgtk_only() must be called
        an equal number of times to begin processing exposes.
        
        This function is not part of the GDK public API and is only
        for use by GTK+.
        @returns: 
        @rtype: None
        """
        return object
    
    def freeze_updates(self):
        """        Temporarily freezes a window such that it won’t receive expose
        events.  The window will begin receiving expose events again when
        gdk_window_thaw_updates() is called. If gdk_window_freeze_updates()
        has been called more than once, gdk_window_thaw_updates() must be called
        an equal number of times to begin processing exposes.
        @returns: 
        @rtype: None
        """
        return object
    
    def fullscreen(self):
        """        Moves the window into fullscreen mode. This means the
        window covers the entire screen and is above any panels
        or task bars.
        
        If the window was already fullscreen, then this function does nothing.
        
        On X11, asks the window manager to put @window in a fullscreen
        state, if the window manager supports this operation. Not all
        window managers support this, and some deliberately ignore it or
        don’t have a concept of “fullscreen”; so you can’t rely on the
        fullscreenification actually happening. But it will happen with
        most standard window managers, and GDK makes a best effort to get
        it to happen.
        @returns: 
        @rtype: None
        """
        return object
    
    def fullscreen_on_monitor(self, monitor=None):
        """        Moves the window into fullscreen mode on the given monitor. This means
        the window covers the entire screen and is above any panels or task bars.
        
        If the window was already fullscreen, then this function does nothing.
        @param monitor: Which monitor to display fullscreen on.
        @type monitor: int
        @returns: 
        @rtype: None
        """
        return object
    
    def geometry_changed(self):
        """        This function informs GDK that the geometry of an embedded
        offscreen window has changed. This is necessary for GDK to keep
        track of which offscreen window the pointer is in.
        @returns: 
        @rtype: None
        """
        return object
    
    def get_accept_focus(self):
        """        Determines whether or not the desktop environment shuld be hinted that
        the window does not want to receive input focus.
        @returns: whether or not the window should receive input focus.
        @rtype: bool
        """
        return object
    
    def get_background_pattern(self):
        """        Gets the pattern used to clear the background on @window. If @window
        does not have its own background and reuses the parent's, %NULL is
        returned and you’ll have to query it yourself.
        @returns: The pattern to use for the background or %NULL to use the parent’s background.
        @rtype: cairo.Pattern
        """
        return object
    
    def get_children(self):
        """        Gets the list of children of @window known to GDK.
        This function only returns children created via GDK,
        so for example it’s useless when used with the root window;
        it only returns windows an application created itself.
        
        The returned list must be freed, but the elements in the
        list need not be.
        @returns: list of child windows inside @window
        @rtype: GLib.List
        """
        return object
    
    def get_children_with_user_data(self, user_data=None):
        """        Gets the list of children of @window known to GDK with a
        particular @user_data set on it.
        
        The returned list must be freed, but the elements in the
        list need not be.
        
        The list is returned in (relative) stacking order, i.e. the
        lowest window is first.
        @param user_data: user data to look for
        @type user_data: gpointer
        @returns: list of child windows inside @window
        @rtype: GLib.List
        """
        return object
    
    def get_clip_region(self):
        """        Computes the region of a window that potentially can be written
        to by drawing primitives. This region may not take into account
        other factors such as if the window is obscured by other windows,
        but no area outside of this region will be affected by drawing
        primitives.
        @returns: a #cairo_region_t. This must be freed with cairo_region_destroy()
          when you are done.
        @rtype: cairo.Region
        """
        return object
    
    def get_composited(self):
        """        Determines whether @window is composited.
        
        See gdk_window_set_composited().
        @returns: %TRUE if the window is composited.
        @rtype: bool
        """
        return object
    
    def get_cursor(self):
        """        Retrieves a #GdkCursor pointer for the cursor currently set on the
        specified #GdkWindow, or %NULL.  If the return value is %NULL then
        there is no custom cursor set on the specified window, and it is
        using the cursor for its parent window.
        @returns: a #GdkCursor, or %NULL. The
   returned object is owned by the #GdkWindow and should not be
   unreferenced directly. Use gdk_window_set_cursor() to unset the
   cursor of the window
        @rtype: Cursor
        """
        return object
    
    def get_decorations(self, decorations=None):
        """        Returns the decorations set on the GdkWindow with
        gdk_window_set_decorations().
        @param decorations: The window decorations will be written here
        @type decorations: WMDecoration
        @returns: %TRUE if the window has decorations set, %FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def get_device_cursor(self, device=None):
        """        Retrieves a #GdkCursor pointer for the @device currently set on the
        specified #GdkWindow, or %NULL.  If the return value is %NULL then
        there is no custom cursor set on the specified window, and it is
        using the cursor for its parent window.
        @param device: a master, pointer #GdkDevice.
        @type device: Device
        @returns: a #GdkCursor, or %NULL. The
   returned object is owned by the #GdkWindow and should not be
   unreferenced directly. Use gdk_window_set_cursor() to unset the
   cursor of the window
        @rtype: Cursor
        """
        return object
    
    def get_device_events(self, device=None):
        """        Returns the event mask for @window corresponding to an specific device.
        @param device: a #GdkDevice.
        @type device: Device
        @returns: device event mask for @window
        @rtype: EventMask
        """
        return object
    
    def get_device_position(self, device=None, x=None, y=None, mask=None):
        """        Obtains the current device position and modifier state.
        The position is given in coordinates relative to the upper left
        corner of @window.
        
        Use gdk_window_get_device_position_double() if you need subpixel precision.
        @param device: pointer #GdkDevice to query to.
        @param x: return location for the X coordinate of @device, or %NULL.
        @param y: return location for the Y coordinate of @device, or %NULL.
        @param mask: return location for the modifier mask, or %NULL.
        @type device: Device
        @type x: int
        @type y: int
        @type mask: ModifierType
        @returns: The window underneath @device (as with gdk_device_get_window_at_position()), or %NULL if the window is not known to GDK.
        @rtype: Window
        """
        return object
    
    def get_device_position_double(self, device=None, x=None, y=None, mask=None):
        """        Obtains the current device position in doubles and modifier state.
        The position is given in coordinates relative to the upper left
        corner of @window.
        @param device: pointer #GdkDevice to query to.
        @param x: return location for the X coordinate of @device, or %NULL.
        @param y: return location for the Y coordinate of @device, or %NULL.
        @param mask: return location for the modifier mask, or %NULL.
        @type device: Device
        @type x: float
        @type y: float
        @type mask: ModifierType
        @returns: The window underneath @device (as with gdk_device_get_window_at_position()), or %NULL if the window is not known to GDK.
        @rtype: Window
        """
        return object
    
    def get_display(self):
        """        Gets the #GdkDisplay associated with a #GdkWindow.
        @returns: the #GdkDisplay associated with @window
        @rtype: Display
        """
        return object
    
    def get_drag_protocol(self, target=None):
        """        Finds out the DND protocol supported by a window.
        @param target: location of the window    where the drop should happen. This may be @window or a proxy window,    or %NULL if @window does not support Drag and Drop.
        @type target: Window
        @returns: the supported DND protocol.
        @rtype: DragProtocol
        """
        return object
    
    def get_effective_parent(self):
        """        Obtains the parent of @window, as known to GDK. Works like
        gdk_window_get_parent() for normal windows, but returns the
        window’s embedder for offscreen windows.
        
        See also: gdk_offscreen_window_get_embedder()
        @returns: effective parent of @window
        @rtype: Window
        """
        return object
    
    def get_effective_toplevel(self):
        """        Gets the toplevel window that’s an ancestor of @window.
        
        Works like gdk_window_get_toplevel(), but treats an offscreen window's
        embedder as its parent, using gdk_window_get_effective_parent().
        
        See also: gdk_offscreen_window_get_embedder()
        @returns: the effective toplevel window containing @window
        @rtype: Window
        """
        return object
    
    def get_event_compression(self):
        """        Get the current event compression setting for this window.
        @returns: %TRUE if motion events will be compressed
        @rtype: bool
        """
        return object
    
    def get_events(self):
        """        Gets the event mask for @window for all master input devices. See
        gdk_window_set_events().
        @returns: event mask for @window
        @rtype: EventMask
        """
        return object
    
    def get_focus_on_map(self):
        """        Determines whether or not the desktop environment should be hinted that the
        window does not want to receive input focus when it is mapped.
        @returns: whether or not the window wants to receive input focus when it is mapped.
        @rtype: bool
        """
        return object
    
    def get_frame_clock(self):
        """        Gets the frame clock for the window. The frame clock for a window
        never changes unless the window is reparented to a new toplevel
        window.
        @returns: the frame clock
        @rtype: FrameClock
        """
        return object
    
    def get_frame_extents(self, rect=None):
        """        Obtains the bounding box of the window, including window manager
        titlebar/borders if any. The frame position is given in root window
        coordinates. To get the position of the window itself (rather than
        the frame) in root window coordinates, use gdk_window_get_origin().
        @param rect: rectangle to fill with bounding box of the window frame
        @type rect: Rectangle
        @returns: 
        @rtype: None
        """
        return object
    
    def get_fullscreen_mode(self):
        """        Obtains the #GdkFullscreenMode of the @window.
        @returns: The #GdkFullscreenMode applied to the window when fullscreen.
        @rtype: FullscreenMode
        """
        return object
    
    def get_geometry(self, x=None, y=None, width=None, height=None):
        """        Any of the return location arguments to this function may be %NULL,
        if you aren’t interested in getting the value of that field.
        
        The X and Y coordinates returned are relative to the parent window
        of @window, which for toplevels usually means relative to the
        window decorations (titlebar, etc.) rather than relative to the
        root window (screen-size background window).
        
        On the X11 platform, the geometry is obtained from the X server,
        so reflects the latest position of @window; this may be out-of-sync
        with the position of @window delivered in the most-recently-processed
        #GdkEventConfigure. gdk_window_get_position() in contrast gets the
        position from the most recent configure event.
        
        Note: If @window is not a toplevel, it is much better
        to call gdk_window_get_position(), gdk_window_get_width() and
        gdk_window_get_height() instead, because it avoids the roundtrip to
        the X server and because these functions support the full 32-bit
        coordinate space, whereas gdk_window_get_geometry() is restricted to
        the 16-bit coordinates of X11.
        @param x: return location for X coordinate of window (relative to its parent)
        @param y: return location for Y coordinate of window (relative to its parent)
        @param width: return location for width of window
        @param height: return location for height of window
        @type x: int
        @type y: int
        @type width: int
        @type height: int
        @returns: 
        @rtype: None
        """
        return object
    
    def get_group(self):
        """        Returns the group leader window for @window. See gdk_window_set_group().
        @returns: the group leader window for @window
        @rtype: Window
        """
        return object
    
    def get_height(self):
        """        Returns the height of the given @window.
        
        On the X11 platform the returned size is the size reported in the
        most-recently-processed configure event, rather than the current
        size on the X server.
        @returns: The height of @window
        @rtype: int
        """
        return object
    
    def get_modal_hint(self):
        """        Determines whether or not the window manager is hinted that @window
        has modal behaviour.
        @returns: whether or not the window has the modal hint set.
        @rtype: bool
        """
        return object
    
    def get_origin(self, x=None, y=None):
        """        Obtains the position of a window in root window coordinates.
        (Compare with gdk_window_get_position() and
        gdk_window_get_geometry() which return the position of a window
        relative to its parent window.)
        @param x: return location for X coordinate
        @param y: return location for Y coordinate
        @type x: int
        @type y: int
        @returns: not meaningful, ignore
        @rtype: int
        """
        return object
    
    def get_parent(self):
        """        Obtains the parent of @window, as known to GDK. Does not query the
        X server; thus this returns the parent as passed to gdk_window_new(),
        not the actual parent. This should never matter unless you’re using
        Xlib calls mixed with GDK calls on the X11 platform. It may also
        matter for toplevel windows, because the window manager may choose
        to reparent them.
        
        Note that you should use gdk_window_get_effective_parent() when
        writing generic code that walks up a window hierarchy, because
        gdk_window_get_parent() will most likely not do what you expect if
        there are offscreen windows in the hierarchy.
        @returns: parent of @window
        @rtype: Window
        """
        return object
    
    def get_pass_through(self):
        """        Returns whether input to the window is passed through to the window
        below.
        
        See gdk_window_set_pass_through() for details
        @returns: 
        @rtype: bool
        """
        return object
    
    def get_pointer(self, x=None, y=None, mask=None):
        """        Obtains the current pointer position and modifier state.
        The position is given in coordinates relative to the upper left
        corner of @window.
        @param x: return location for X coordinate of pointer or %NULL to not      return the X coordinate
        @param y: return location for Y coordinate of pointer or %NULL to not      return the Y coordinate
        @param mask: return location for modifier mask or %NULL to not return the      modifier mask
        @type x: int
        @type y: int
        @type mask: ModifierType
        @returns: the window containing the pointer (as with gdk_window_at_pointer()), or %NULL if the window containing the pointer isn’t known to GDK
        @rtype: Window
        """
        return object
    
    def get_position(self, x=None, y=None):
        """        Obtains the position of the window as reported in the
        most-recently-processed #GdkEventConfigure. Contrast with
        gdk_window_get_geometry() which queries the X server for the
        current window position, regardless of which events have been
        received or processed.
        
        The position coordinates are relative to the window’s parent window.
        @param x: X coordinate of window
        @param y: Y coordinate of window
        @type x: int
        @type y: int
        @returns: 
        @rtype: None
        """
        return object
    
    def get_root_coords(self, x=None, y=None, root_x=None, root_y=None):
        """        Obtains the position of a window position in root
        window coordinates. This is similar to
        gdk_window_get_origin() but allows you to pass
        in any position in the window, not just the origin.
        @param x: X coordinate in window
        @param y: Y coordinate in window
        @param root_x: return location for X coordinate
        @param root_y: return location for Y coordinate
        @type x: int
        @type y: int
        @type root_x: int
        @type root_y: int
        @returns: 
        @rtype: None
        """
        return object
    
    def get_root_origin(self, x=None, y=None):
        """        Obtains the top-left corner of the window manager frame in root
        window coordinates.
        @param x: return location for X position of window frame
        @param y: return location for Y position of window frame
        @type x: int
        @type y: int
        @returns: 
        @rtype: None
        """
        return object
    
    def get_scale_factor(self):
        """        Returns the internal scale factor that maps from window coordiantes
        to the actual device pixels. On traditional systems this is 1, but
        on very high density outputs this can be a higher value (often 2).
        
        A higher value means that drawing is automatically scaled up to
        a higher resolution, so any code doing drawing will automatically look
        nicer. However, if you are supplying pixel-based data the scale
        value can be used to determine whether to use a pixel resource
        with higher resolution data.
        
        The scale of a window may change during runtime, if this happens
        a configure event will be sent to the toplevel window.
        @returns: the scale factor
        @rtype: int
        """
        return object
    
    def get_screen(self):
        """        Gets the #GdkScreen associated with a #GdkWindow.
        @returns: the #GdkScreen associated with @window
        @rtype: Screen
        """
        return object
    
    def get_source_events(self, source=None):
        """        Returns the event mask for @window corresponding to the device class specified
        by @source.
        @param source: a #GdkInputSource to define the source class.
        @type source: InputSource
        @returns: source event mask for @window
        @rtype: EventMask
        """
        return object
    
    def get_state(self):
        """        Gets the bitwise OR of the currently active window state flags,
        from the #GdkWindowState enumeration.
        @returns: window state bitfield
        @rtype: WindowState
        """
        return object
    
    def get_support_multidevice(self):
        """        Returns %TRUE if the window is aware of the existence of multiple
        devices.
        @returns: %TRUE if the window handles multidevice features.
        @rtype: bool
        """
        return object
    
    def get_toplevel(self):
        """        Gets the toplevel window that’s an ancestor of @window.
        
        Any window type but %GDK_WINDOW_CHILD is considered a
        toplevel window, as is a %GDK_WINDOW_CHILD window that
        has a root window as parent.
        
        Note that you should use gdk_window_get_effective_toplevel() when
        you want to get to a window’s toplevel as seen on screen, because
        gdk_window_get_toplevel() will most likely not do what you expect
        if there are offscreen windows in the hierarchy.
        @returns: the toplevel window containing @window
        @rtype: Window
        """
        return object
    
    def get_type_hint(self):
        """        This function returns the type hint set for a window.
        @returns: The type hint set for @window
        @rtype: WindowTypeHint
        """
        return object
    
    def get_update_area(self):
        """        Transfers ownership of the update area from @window to the caller
        of the function. That is, after calling this function, @window will
        no longer have an invalid/dirty region; the update area is removed
        from @window and handed to you. If a window has no update area,
        gdk_window_get_update_area() returns %NULL. You are responsible for
        calling cairo_region_destroy() on the returned region if it’s non-%NULL.
        @returns: the update area for @window
        @rtype: cairo.Region
        """
        return object
    
    def get_user_data(self, data=None):
        """        Retrieves the user data for @window, which is normally the widget
        that @window belongs to. See gdk_window_set_user_data().
        @param data: return location for user data
        @type data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def get_visible_region(self):
        """        Computes the region of the @window that is potentially visible.
        This does not necessarily take into account if the window is
        obscured by other windows, but no area outside of this region
        is visible.
        @returns: a #cairo_region_t. This must be freed with cairo_region_destroy()
          when you are done.
        @rtype: cairo.Region
        """
        return object
    
    def get_visual(self):
        """        Gets the #GdkVisual describing the pixel format of @window.
        @returns: a #GdkVisual
        @rtype: Visual
        """
        return object
    
    def get_width(self):
        """        Returns the width of the given @window.
        
        On the X11 platform the returned size is the size reported in the
        most-recently-processed configure event, rather than the current
        size on the X server.
        @returns: The width of @window
        @rtype: int
        """
        return object
    
    def get_window_type(self):
        """        Gets the type of the window. See #GdkWindowType.
        @returns: type of window
        @rtype: WindowType
        """
        return object
    
    def has_native(self):
        """        Checks whether the window has a native window or not. Note that
        you can use gdk_window_ensure_native() if a native window is needed.
        @returns: %TRUE if the @window has a native window, %FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def hide(self):
        """        For toplevel windows, withdraws them, so they will no longer be
        known to the window manager; for all windows, unmaps them, so
        they won’t be displayed. Normally done automatically as
        part of gtk_widget_hide().
        @returns: 
        @rtype: None
        """
        return object
    
    def iconify(self):
        """        Asks to iconify (minimize) @window. The window manager may choose
        to ignore the request, but normally will honor it. Using
        gtk_window_iconify() is preferred, if you have a #GtkWindow widget.
        
        This function only makes sense when @window is a toplevel window.
        @returns: 
        @rtype: None
        """
        return object
    
    def input_shape_combine_region(self, shape_region=None, offset_x=None, offset_y=None):
        """        Like gdk_window_shape_combine_region(), but the shape applies
        only to event handling. Mouse events which happen while
        the pointer position corresponds to an unset bit in the
        mask will be passed on the window below @window.
        
        An input shape is typically used with RGBA windows.
        The alpha channel of the window defines which pixels are
        invisible and allows for nicely antialiased borders,
        and the input shape controls where the window is
        “clickable”.
        
        On the X11 platform, this requires version 1.1 of the
        shape extension.
        
        On the Win32 platform, this functionality is not present and the
        function does nothing.
        @param shape_region: region of window to be non-transparent
        @param offset_x: X position of @shape_region in @window coordinates
        @param offset_y: Y position of @shape_region in @window coordinates
        @type shape_region: cairo.Region
        @type offset_x: int
        @type offset_y: int
        @returns: 
        @rtype: None
        """
        return object
    
    def invalidate_maybe_recurse(self, region=None, child_func=None, user_data=None):
        """        Adds @region to the update area for @window. The update area is the
        region that needs to be redrawn, or “dirty region.” The call
        gdk_window_process_updates() sends one or more expose events to the
        window, which together cover the entire update area. An
        application would normally redraw the contents of @window in
        response to those expose events.
        
        GDK will call gdk_window_process_all_updates() on your behalf
        whenever your program returns to the main loop and becomes idle, so
        normally there’s no need to do that manually, you just need to
        invalidate regions that you know should be redrawn.
        
        The @child_func parameter controls whether the region of
        each child window that intersects @region will also be invalidated.
        Only children for which @child_func returns #TRUE will have the area
        invalidated.
        @param region: a #cairo_region_t
        @param child_func: function to use to decide if to     recurse to a child, %NULL means never recurse.
        @param user_data: data passed to @child_func
        @type region: cairo.Region
        @type child_func: WindowChildFunc
        @type user_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def invalidate_rect(self, rect=None, invalidate_children=None):
        """        A convenience wrapper around gdk_window_invalidate_region() which
        invalidates a rectangular region. See
        gdk_window_invalidate_region() for details.
        @param rect: rectangle to invalidate or %NULL to invalidate the whole      window
        @param invalidate_children: whether to also invalidate child windows
        @type rect: Rectangle
        @type invalidate_children: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def invalidate_region(self, region=None, invalidate_children=None):
        """        Adds @region to the update area for @window. The update area is the
        region that needs to be redrawn, or “dirty region.” The call
        gdk_window_process_updates() sends one or more expose events to the
        window, which together cover the entire update area. An
        application would normally redraw the contents of @window in
        response to those expose events.
        
        GDK will call gdk_window_process_all_updates() on your behalf
        whenever your program returns to the main loop and becomes idle, so
        normally there’s no need to do that manually, you just need to
        invalidate regions that you know should be redrawn.
        
        The @invalidate_children parameter controls whether the region of
        each child window that intersects @region will also be invalidated.
        If %FALSE, then the update area for child windows will remain
        unaffected. See gdk_window_invalidate_maybe_recurse if you need
        fine grained control over which children are invalidated.
        @param region: a #cairo_region_t
        @param invalidate_children: %TRUE to also invalidate child windows
        @type region: cairo.Region
        @type invalidate_children: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def is_destroyed(self):
        """        Check to see if a window is destroyed..
        @returns: %TRUE if the window is destroyed
        @rtype: bool
        """
        return object
    
    def is_input_only(self):
        """        Determines whether or not the window is an input only window.
        @returns: %TRUE if @window is input only
        @rtype: bool
        """
        return object
    
    def is_shaped(self):
        """        Determines whether or not the window is shaped.
        @returns: %TRUE if @window is shaped
        @rtype: bool
        """
        return object
    
    def is_viewable(self):
        """        Check if the window and all ancestors of the window are
        mapped. (This is not necessarily "viewable" in the X sense, since
        we only check as far as we have GDK window parents, not to the root
        window.)
        @returns: %TRUE if the window is viewable
        @rtype: bool
        """
        return object
    
    def is_visible(self):
        """        Checks whether the window has been mapped (with gdk_window_show() or
        gdk_window_show_unraised()).
        @returns: %TRUE if the window is mapped
        @rtype: bool
        """
        return object
    
    def lower(self):
        """        Lowers @window to the bottom of the Z-order (stacking order), so that
        other windows with the same parent window appear above @window.
        This is true whether or not the other windows are visible.
        
        If @window is a toplevel, the window manager may choose to deny the
        request to move the window in the Z-order, gdk_window_lower() only
        requests the restack, does not guarantee it.
        
        Note that gdk_window_show() raises the window again, so don’t call this
        function before gdk_window_show(). (Try gdk_window_show_unraised().)
        @returns: 
        @rtype: None
        """
        return object
    
    def mark_paint_from_clip(self, cr=None):
        """        If you call this during a paint (e.g. between gdk_window_begin_paint_region()
        and gdk_window_end_paint() then GDK will mark the current clip region of the
        window as being drawn. This is required when mixing GL rendering via
        gdk_cairo_draw_from_gl() and cairo rendering, as otherwise GDK has no way
        of knowing when something paints over the GL-drawn regions.
        
        This is typically called automatically by GTK+ and you don't need
        to care about this.
        @param cr: a #cairo_t
        @type cr: cairo.Context
        @returns: 
        @rtype: None
        """
        return object
    
    def maximize(self):
        """        Maximizes the window. If the window was already maximized, then
        this function does nothing.
        
        On X11, asks the window manager to maximize @window, if the window
        manager supports this operation. Not all window managers support
        this, and some deliberately ignore it or don’t have a concept of
        “maximized”; so you can’t rely on the maximization actually
        happening. But it will happen with most standard window managers,
        and GDK makes a best effort to get it to happen.
        
        On Windows, reliably maximizes the window.
        @returns: 
        @rtype: None
        """
        return object
    
    def merge_child_input_shapes(self):
        """        Merges the input shape masks for any child windows into the
        input shape mask for @window. i.e. the union of all input masks
        for @window and its children will become the new input mask
        for @window. See gdk_window_input_shape_combine_region().
        
        This function is distinct from gdk_window_set_child_input_shapes()
        because it includes @window’s input shape mask in the set of
        shapes to be merged.
        @returns: 
        @rtype: None
        """
        return object
    
    def merge_child_shapes(self):
        """        Merges the shape masks for any child windows into the
        shape mask for @window. i.e. the union of all masks
        for @window and its children will become the new mask
        for @window. See gdk_window_shape_combine_region().
        
        This function is distinct from gdk_window_set_child_shapes()
        because it includes @window’s shape mask in the set of shapes to
        be merged.
        @returns: 
        @rtype: None
        """
        return object
    
    def move(self, x=None, y=None):
        """        Repositions a window relative to its parent window.
        For toplevel windows, window managers may ignore or modify the move;
        you should probably use gtk_window_move() on a #GtkWindow widget
        anyway, instead of using GDK functions. For child windows,
        the move will reliably succeed.
        
        If you’re also planning to resize the window, use gdk_window_move_resize()
        to both move and resize simultaneously, for a nicer visual effect.
        @param x: X coordinate relative to window’s parent
        @param y: Y coordinate relative to window’s parent
        @type x: int
        @type y: int
        @returns: 
        @rtype: None
        """
        return object
    
    def move_region(self, region=None, dx=None, dy=None):
        """        Move the part of @window indicated by @region by @dy pixels in the Y
        direction and @dx pixels in the X direction. The portions of @region
        that not covered by the new position of @region are invalidated.
        
        Child windows are not moved.
        @param region: The #cairo_region_t to move
        @param dx: Amount to move in the X direction
        @param dy: Amount to move in the Y direction
        @type region: cairo.Region
        @type dx: int
        @type dy: int
        @returns: 
        @rtype: None
        """
        return object
    
    def move_resize(self, x=None, y=None, width=None, height=None):
        """        Equivalent to calling gdk_window_move() and gdk_window_resize(),
        except that both operations are performed at once, avoiding strange
        visual effects. (i.e. the user may be able to see the window first
        move, then resize, if you don’t use gdk_window_move_resize().)
        @param x: new X position relative to window’s parent
        @param y: new Y position relative to window’s parent
        @param width: new width
        @param height: new height
        @type x: int
        @type y: int
        @type width: int
        @type height: int
        @returns: 
        @rtype: None
        """
        return object
    
    def peek_children(self):
        """        Like gdk_window_get_children(), but does not copy the list of
        children, so the list does not need to be freed.
        @returns: a reference to the list of child windows in @window
        @rtype: GLib.List
        """
        return object
    
    def process_updates(self, update_children=None):
        """        Sends one or more expose events to @window. The areas in each
        expose event will cover the entire update area for the window (see
        gdk_window_invalidate_region() for details). Normally GDK calls
        gdk_window_process_all_updates() on your behalf, so there’s no
        need to call this function unless you want to force expose events
        to be delivered immediately and synchronously (vs. the usual
        case, where GDK delivers them in an idle handler). Occasionally
        this is useful to produce nicer scrolling behavior, for example.
        @param update_children: whether to also process updates for child windows
        @type update_children: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def _raise(self):
        """        Raises @window to the top of the Z-order (stacking order), so that
        other windows with the same parent window appear below @window.
        This is true whether or not the windows are visible.
        
        If @window is a toplevel, the window manager may choose to deny the
        request to move the window in the Z-order, gdk_window_raise() only
        requests the restack, does not guarantee it.
        @returns: 
        @rtype: None
        """
        return object
    
    def register_dnd(self):
        """        Registers a window as a potential drop destination.
        @returns: 
        @rtype: None
        """
        return object
    
    def remove_filter(self, function=None, data=None):
        """        Remove a filter previously added with gdk_window_add_filter().
        @param function: previously-added filter function
        @param data: user data for previously-added filter function
        @type function: FilterFunc
        @type data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def reparent(self, new_parent=None, x=None, y=None):
        """        Reparents @window into the given @new_parent. The window being
        reparented will be unmapped as a side effect.
        @param new_parent: new parent to move @window into
        @param x: X location inside the new parent
        @param y: Y location inside the new parent
        @type new_parent: Window
        @type x: int
        @type y: int
        @returns: 
        @rtype: None
        """
        return object
    
    def resize(self, width=None, height=None):
        """        Resizes @window; for toplevel windows, asks the window manager to resize
        the window. The window manager may not allow the resize. When using GTK+,
        use gtk_window_resize() instead of this low-level GDK function.
        
        Windows may not be resized below 1x1.
        
        If you’re also planning to move the window, use gdk_window_move_resize()
        to both move and resize simultaneously, for a nicer visual effect.
        @param width: new width of the window
        @param height: new height of the window
        @type width: int
        @type height: int
        @returns: 
        @rtype: None
        """
        return object
    
    def restack(self, sibling=None, above=None):
        """        Changes the position of  @window in the Z-order (stacking order), so that
        it is above @sibling (if @above is %TRUE) or below @sibling (if @above is
        %FALSE).
        
        If @sibling is %NULL, then this either raises (if @above is %TRUE) or
        lowers the window.
        
        If @window is a toplevel, the window manager may choose to deny the
        request to move the window in the Z-order, gdk_window_restack() only
        requests the restack, does not guarantee it.
        @param sibling: a #GdkWindow that is a sibling of @window, or %NULL
        @param above: a boolean
        @type sibling: Window
        @type above: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def scroll(self, dx=None, dy=None):
        """        Scroll the contents of @window, both pixels and children, by the
        given amount. @window itself does not move. Portions of the window
        that the scroll operation brings in from offscreen areas are
        invalidated. The invalidated region may be bigger than what would
        strictly be necessary.
        
        For X11, a minimum area will be invalidated if the window has no
        subwindows, or if the edges of the window’s parent do not extend
        beyond the edges of the window. In other cases, a multi-step process
        is used to scroll the window which may produce temporary visual
        artifacts and unnecessary invalidations.
        @param dx: Amount to scroll in the X direction
        @param dy: Amount to scroll in the Y direction
        @type dx: int
        @type dy: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_accept_focus(self, accept_focus=None):
        """        Setting @accept_focus to %FALSE hints the desktop environment that the
        window doesn’t want to receive input focus.
        
        On X, it is the responsibility of the window manager to interpret this
        hint. ICCCM-compliant window manager usually respect it.
        @param accept_focus: %TRUE if the window should receive input focus
        @type accept_focus: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def set_background(self, color=None):
        """        Sets the background color of @window.
        
        However, when using GTK+, influence the background of a widget
        using a style class or CSS — if you’re an application — or with
        gtk_style_context_set_background() — if you're implementing a
        custom widget.
        @param color: a #GdkColor
        @type color: Color
        @returns: 
        @rtype: None
        """
        return object
    
    def set_background_pattern(self, pattern=None):
        """        Sets the background of @window.
        
        A background of %NULL means that the window will inherit its
        background from its parent window.
        
        The windowing system will normally fill a window with its background
        when the window is obscured then exposed.
        @param pattern: a pattern to use, or %NULL
        @type pattern: cairo.Pattern
        @returns: 
        @rtype: None
        """
        return object
    
    def set_background_rgba(self, rgba=None):
        """        Sets the background color of @window.
        
        See also gdk_window_set_background_pattern().
        @param rgba: a #GdkRGBA color
        @type rgba: RGBA
        @returns: 
        @rtype: None
        """
        return object
    
    def set_child_input_shapes(self):
        """        Sets the input shape mask of @window to the union of input shape masks
        for all children of @window, ignoring the input shape mask of @window
        itself. Contrast with gdk_window_merge_child_input_shapes() which includes
        the input shape mask of @window in the masks to be merged.
        @returns: 
        @rtype: None
        """
        return object
    
    def set_child_shapes(self):
        """        Sets the shape mask of @window to the union of shape masks
        for all children of @window, ignoring the shape mask of @window
        itself. Contrast with gdk_window_merge_child_shapes() which includes
        the shape mask of @window in the masks to be merged.
        @returns: 
        @rtype: None
        """
        return object
    
    def set_composited(self, composited=None):
        """        Sets a #GdkWindow as composited, or unsets it. Composited
        windows do not automatically have their contents drawn to
        the screen. Drawing is redirected to an offscreen buffer
        and an expose event is emitted on the parent of the composited
        window. It is the responsibility of the parent’s expose handler
        to manually merge the off-screen content onto the screen in
        whatever way it sees fit.
        
        It only makes sense for child windows to be composited; see
        gdk_window_set_opacity() if you need translucent toplevel
        windows.
        
        An additional effect of this call is that the area of this
        window is no longer clipped from regions marked for
        invalidation on its parent. Draws done on the parent
        window are also no longer clipped by the child.
        
        This call is only supported on some systems (currently,
        only X11 with new enough Xcomposite and Xdamage extensions).
        You must call gdk_display_supports_composite() to check if
        setting a window as composited is supported before
        attempting to do so.
        @param composited: %TRUE to set the window as composited
        @type composited: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def set_cursor(self, cursor=None):
        """        Sets the default mouse pointer for a #GdkWindow.
        
        Note that @cursor must be for the same display as @window.
        
        Use gdk_cursor_new_for_display() or gdk_cursor_new_from_pixbuf() to
        create the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR.
        Passing %NULL for the @cursor argument to gdk_window_set_cursor() means
        that @window will use the cursor of its parent window. Most windows
        should use this default.
        @param cursor: a cursor
        @type cursor: Cursor
        @returns: 
        @rtype: None
        """
        return object
    
    def set_decorations(self, decorations=None):
        """        “Decorations” are the features the window manager adds to a toplevel #GdkWindow.
        This function sets the traditional Motif window manager hints that tell the
        window manager which decorations you would like your window to have.
        Usually you should use gtk_window_set_decorated() on a #GtkWindow instead of
        using the GDK function directly.
        
        The @decorations argument is the logical OR of the fields in
        the #GdkWMDecoration enumeration. If #GDK_DECOR_ALL is included in the
        mask, the other bits indicate which decorations should be turned off.
        If #GDK_DECOR_ALL is not included, then the other bits indicate
        which decorations should be turned on.
        
        Most window managers honor a decorations hint of 0 to disable all decorations,
        but very few honor all possible combinations of bits.
        @param decorations: decoration hint mask
        @type decorations: WMDecoration
        @returns: 
        @rtype: None
        """
        return object
    
    def set_device_cursor(self, device=None, cursor=None):
        """        Sets a specific #GdkCursor for a given device when it gets inside @window.
        Use gdk_cursor_new_for_display() or gdk_cursor_new_from_pixbuf() to create
        the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR. Passing
        %NULL for the @cursor argument to gdk_window_set_cursor() means that
        @window will use the cursor of its parent window. Most windows should
        use this default.
        @param device: a master, pointer #GdkDevice
        @param cursor: a #GdkCursor
        @type device: Device
        @type cursor: Cursor
        @returns: 
        @rtype: None
        """
        return object
    
    def set_device_events(self, device=None, event_mask=None):
        """        Sets the event mask for a given device (Normally a floating device, not
        attached to any visible pointer) to @window. For example, an event mask
        including #GDK_BUTTON_PRESS_MASK means the window should report button
        press events. The event mask is the bitwise OR of values from the
        #GdkEventMask enumeration.
        
        See the [input handling overview][event-masks] for details.
        @param device: #GdkDevice to enable events for.
        @param event_mask: event mask for @window
        @type device: Device
        @type event_mask: EventMask
        @returns: 
        @rtype: None
        """
        return object
    
    def set_event_compression(self, event_compression=None):
        """        Determines whether or not extra unprocessed motion events in
        the event queue can be discarded. If %TRUE only the most recent
        event will be delivered.
        
        Some types of applications, e.g. paint programs, need to see all
        motion events and will benefit from turning off event compression.
        
        By default, event compression is enabled.
        @param event_compression: %TRUE if motion events should be compressed
        @type event_compression: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def set_events(self, event_mask=None):
        """        The event mask for a window determines which events will be reported
        for that window from all master input devices. For example, an event mask
        including #GDK_BUTTON_PRESS_MASK means the window should report button
        press events. The event mask is the bitwise OR of values from the
        #GdkEventMask enumeration.
        
        See the [input handling overview][event-masks] for details.
        @param event_mask: event mask for @window
        @type event_mask: EventMask
        @returns: 
        @rtype: None
        """
        return object
    
    def set_focus_on_map(self, focus_on_map=None):
        """        Setting @focus_on_map to %FALSE hints the desktop environment that the
        window doesn’t want to receive input focus when it is mapped.
        focus_on_map should be turned off for windows that aren’t triggered
        interactively (such as popups from network activity).
        
        On X, it is the responsibility of the window manager to interpret
        this hint. Window managers following the freedesktop.org window
        manager extension specification should respect it.
        @param focus_on_map: %TRUE if the window should receive input focus when mapped
        @type focus_on_map: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def set_fullscreen_mode(self, mode=None):
        """        Specifies whether the @window should span over all monitors (in a multi-head
        setup) or only the current monitor when in fullscreen mode.
        
        The @mode argument is from the #GdkFullscreenMode enumeration.
        If #GDK_FULLSCREEN_ON_ALL_MONITORS is specified, the fullscreen @window will
        span over all monitors from the #GdkScreen.
        
        On X11, searches through the list of monitors from the #GdkScreen the ones
        which delimit the 4 edges of the entire #GdkScreen and will ask the window
        manager to span the @window over these monitors.
        
        If the XINERAMA extension is not available or not usable, this function
        has no effect.
        
        Not all window managers support this, so you can’t rely on the fullscreen
        window to span over the multiple monitors when #GDK_FULLSCREEN_ON_ALL_MONITORS
        is specified.
        @param mode: fullscreen mode
        @type mode: FullscreenMode
        @returns: 
        @rtype: None
        """
        return object
    
    def set_functions(self, functions=None):
        """        Sets hints about the window management functions to make available
        via buttons on the window frame.
        
        On the X backend, this function sets the traditional Motif window
        manager hint for this purpose. However, few window managers do
        anything reliable or interesting with this hint. Many ignore it
        entirely.
        
        The @functions argument is the logical OR of values from the
        #GdkWMFunction enumeration. If the bitmask includes #GDK_FUNC_ALL,
        then the other bits indicate which functions to disable; if
        it doesn’t include #GDK_FUNC_ALL, it indicates which functions to
        enable.
        @param functions: bitmask of operations to allow on @window
        @type functions: WMFunction
        @returns: 
        @rtype: None
        """
        return object
    
    def set_geometry_hints(self, geometry=None, geom_mask=None):
        """        Sets the geometry hints for @window. Hints flagged in @geom_mask
        are set, hints not flagged in @geom_mask are unset.
        To unset all hints, use a @geom_mask of 0 and a @geometry of %NULL.
        
        This function provides hints to the windowing system about
        acceptable sizes for a toplevel window. The purpose of
        this is to constrain user resizing, but the windowing system
        will typically  (but is not required to) also constrain the
        current size of the window to the provided values and
        constrain programatic resizing via gdk_window_resize() or
        gdk_window_move_resize().
        
        Note that on X11, this effect has no effect on windows
        of type %GDK_WINDOW_TEMP or windows where override redirect
        has been turned on via gdk_window_set_override_redirect()
        since these windows are not resizable by the user.
        
        Since you can’t count on the windowing system doing the
        constraints for programmatic resizes, you should generally
        call gdk_window_constrain_size() yourself to determine
        appropriate sizes.
        @param geometry: geometry hints
        @param geom_mask: bitmask indicating fields of @geometry to pay attention to
        @type geometry: Geometry
        @type geom_mask: WindowHints
        @returns: 
        @rtype: None
        """
        return object
    
    def set_group(self, leader=None):
        """        Sets the group leader window for @window. By default,
        GDK sets the group leader for all toplevel windows
        to a global window implicitly created by GDK. With this function
        you can override this default.
        
        The group leader window allows the window manager to distinguish
        all windows that belong to a single application. It may for example
        allow users to minimize/unminimize all windows belonging to an
        application at once. You should only set a non-default group window
        if your application pretends to be multiple applications.
        @param leader: group leader window, or %NULL to restore the default group leader window
        @type leader: Window
        @returns: 
        @rtype: None
        """
        return object
    
    def set_icon_list(self, pixbufs=None):
        """        Sets a list of icons for the window. One of these will be used
        to represent the window when it has been iconified. The icon is
        usually shown in an icon box or some sort of task bar. Which icon
        size is shown depends on the window manager. The window manager
        can scale the icon  but setting several size icons can give better
        image quality since the window manager may only need to scale the
        icon by a small amount or not at all.
        
        Note that some platforms don't support window icons.
        @param pixbufs: A list of pixbufs, of different sizes.
        @type pixbufs: GLib.List
        @returns: 
        @rtype: None
        """
        return object
    
    def set_icon_name(self, name=None):
        """        Windows may have a name used while minimized, distinct from the
        name they display in their titlebar. Most of the time this is a bad
        idea from a user interface standpoint. But you can set such a name
        with this function, if you like.
        
        After calling this with a non-%NULL @name, calls to gdk_window_set_title()
        will not update the icon title.
        
        Using %NULL for @name unsets the icon title; further calls to
        gdk_window_set_title() will again update the icon title as well.
        
        Note that some platforms don't support window icons.
        @param name: name of window while iconified (minimized)
        @type name: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_invalidate_handler(self, handler=None):
        """        Registers an invalidate handler for a specific window. This
        will get called whenever a region in the window or its children
        is invalidated.
        
        This can be used to record the invalidated region, which is
        useful if you are keeping an offscreen copy of some region
        and want to keep it up to date. You can also modify the
        invalidated region in case you’re doing some effect where
        e.g. a child widget appears in multiple places.
        @param handler: a #GdkWindowInvalidateHandlerFunc callback function
        @type handler: WindowInvalidateHandlerFunc
        @returns: 
        @rtype: None
        """
        return object
    
    def set_keep_above(self, setting=None):
        """        Set if @window must be kept above other windows. If the
        window was already above, then this function does nothing.
        
        On X11, asks the window manager to keep @window above, if the window
        manager supports this operation. Not all window managers support
        this, and some deliberately ignore it or don’t have a concept of
        “keep above”; so you can’t rely on the window being kept above.
        But it will happen with most standard window managers,
        and GDK makes a best effort to get it to happen.
        @param setting: whether to keep @window above other windows
        @type setting: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def set_keep_below(self, setting=None):
        """        Set if @window must be kept below other windows. If the
        window was already below, then this function does nothing.
        
        On X11, asks the window manager to keep @window below, if the window
        manager supports this operation. Not all window managers support
        this, and some deliberately ignore it or don’t have a concept of
        “keep below”; so you can’t rely on the window being kept below.
        But it will happen with most standard window managers,
        and GDK makes a best effort to get it to happen.
        @param setting: whether to keep @window below other windows
        @type setting: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def set_modal_hint(self, modal=None):
        """        The application can use this hint to tell the window manager
        that a certain window has modal behaviour. The window manager
        can use this information to handle modal windows in a special
        way.
        
        You should only use this on windows for which you have
        previously called gdk_window_set_transient_for()
        @param modal: %TRUE if the window is modal, %FALSE otherwise.
        @type modal: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def set_opacity(self, opacity=None):
        """        Set @window to render as partially transparent,
        with opacity 0 being fully transparent and 1 fully opaque. (Values
        of the opacity parameter are clamped to the [0,1] range.)
        
        For toplevel windows this depends on support from the windowing system
        that may not always be there. For instance, On X11, this works only on
        X screens with a compositing manager running. On Wayland, there is no
        per-window opacity value that the compositor would apply. Instead, use
        `gdk_window_set_opaque_region (window, NULL)` to tell the compositor
        that the entire window is (potentially) non-opaque, and draw your content
        with alpha, or use gtk_widget_set_opacity() to set an overall opacity
        for your widgets.
        
        For child windows this function only works for non-native windows.
        
        For setting up per-pixel alpha topelevels, see gdk_screen_get_rgba_visual(),
        and for non-toplevels, see gdk_window_set_composited().
        
        Support for non-toplevel windows was added in 3.8.
        @param opacity: opacity
        @type opacity: float
        @returns: 
        @rtype: None
        """
        return object
    
    def set_opaque_region(self, region=None):
        """        For optimisation purposes, compositing window managers may
        like to not draw obscured regions of windows, or turn off blending
        during for these regions. With RGB windows with no transparency,
        this is just the shape of the window, but with ARGB32 windows, the
        compositor does not know what regions of the window are transparent
        or not.
        
        This function only works for toplevel windows.
        
        GTK+ will update this property automatically if
        the @window background is opaque, as we know where the opaque regions
        are. If your window background is not opaque, please update this
        property in your #GtkWidget::style-updated handler.
        @param region: a region, or %NULL
        @type region: cairo.Region
        @returns: 
        @rtype: None
        """
        return object
    
    def set_override_redirect(self, override_redirect=None):
        """        An override redirect window is not under the control of the window manager.
        This means it won’t have a titlebar, won’t be minimizable, etc. - it will
        be entirely under the control of the application. The window manager
        can’t see the override redirect window at all.
        
        Override redirect should only be used for short-lived temporary
        windows, such as popup menus. #GtkMenu uses an override redirect
        window in its implementation, for example.
        @param override_redirect: %TRUE if window should be override redirect
        @type override_redirect: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def set_pass_through(self, pass_through=None):
        """        Sets whether input to the window is passed through to the window
        below.
        
        The default value of this is %FALSE, which means that pointer
        events that happen inside the window are send first to the window,
        but if the event is not selected by the event mask then the event
        is sent to the parent window, and so on up the hierarchy.
        
        If @pass_through is %TRUE then such pointer events happen as if the
        window wasn't there at all, and thus will be sent first to any
        windows below @window. This is useful if the window is used in a
        transparent fashion. In the terminology of the web this would be called
        "pointer-events: none".
        
        Note that a window with @pass_through %TRUE can still have a subwindow
        without pass through, so you can get events on a subset of a window. And in
        that cases you would get the in-between related events such as the pointer
        enter/leave events on its way to the destination window.
        @param pass_through: a boolean
        @type pass_through: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def set_role(self, role=None):
        """        When using GTK+, typically you should use gtk_window_set_role() instead
        of this low-level function.
        
        The window manager and session manager use a window’s role to
        distinguish it from other kinds of window in the same application.
        When an application is restarted after being saved in a previous
        session, all windows with the same title and role are treated as
        interchangeable.  So if you have two windows with the same title
        that should be distinguished for session management purposes, you
        should set the role on those windows. It doesn’t matter what string
        you use for the role, as long as you have a different role for each
        non-interchangeable kind of window.
        @param role: a string indicating its role
        @type role: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_shadow_width(self, left=None, right=None, top=None, bottom=None):
        """        Newer GTK+ windows using client-side decorations use extra geometry
        around their frames for effects like shadows and invisible borders.
        Window managers that want to maximize windows or snap to edges need
        to know where the extents of the actual frame lie, so that users
        don’t feel like windows are snapping against random invisible edges.
        
        Note that this property is automatically updated by GTK+, so this
        function should only be used by applications which do not use GTK+
        to create toplevel windows.
        @param left: The left extent
        @param right: The right extent
        @param top: The top extent
        @param bottom: The bottom extent
        @type left: int
        @type right: int
        @type top: int
        @type bottom: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_skip_pager_hint(self, skips_pager=None):
        """        Toggles whether a window should appear in a pager (workspace
        switcher, or other desktop utility program that displays a small
        thumbnail representation of the windows on the desktop). If a
        window’s semantic type as specified with gdk_window_set_type_hint()
        already fully describes the window, this function should
        not be called in addition, instead you should
        allow the window to be treated according to standard policy for
        its semantic type.
        @param skips_pager: %TRUE to skip the pager
        @type skips_pager: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def set_skip_taskbar_hint(self, skips_taskbar=None):
        """        Toggles whether a window should appear in a task list or window
        list. If a window’s semantic type as specified with
        gdk_window_set_type_hint() already fully describes the window, this
        function should not be called in addition,
        instead you should allow the window to be treated according to
        standard policy for its semantic type.
        @param skips_taskbar: %TRUE to skip the taskbar
        @type skips_taskbar: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def set_source_events(self, source=None, event_mask=None):
        """        Sets the event mask for any floating device (i.e. not attached to any
        visible pointer) that has the source defined as @source. This event
        mask will be applied both to currently existing, newly added devices
        after this call, and devices being attached/detached.
        @param source: a #GdkInputSource to define the source class.
        @param event_mask: event mask for @window
        @type source: InputSource
        @type event_mask: EventMask
        @returns: 
        @rtype: None
        """
        return object
    
    def set_startup_id(self, startup_id=None):
        """        When using GTK+, typically you should use gtk_window_set_startup_id()
        instead of this low-level function.
        @param startup_id: a string with startup-notification identifier
        @type startup_id: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_static_gravities(self, use_static=None):
        """        Used to set the bit gravity of the given window to static, and flag
        it so all children get static subwindow gravity. This is used if you
        are implementing scary features that involve deep knowledge of the
        windowing system. Don’t worry about it.
        @param use_static: %TRUE to turn on static gravity
        @type use_static: bool
        @returns: %FALSE
        @rtype: bool
        """
        return object
    
    def set_support_multidevice(self, support_multidevice=None):
        """        This function will enable multidevice features in @window.
        
        Multidevice aware windows will need to handle properly multiple,
        per device enter/leave events, device grabs and grab ownerships.
        @param support_multidevice: %TRUE to enable multidevice support in @window.
        @type support_multidevice: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def set_title(self, title=None):
        """        Sets the title of a toplevel window, to be displayed in the titlebar.
        If you haven’t explicitly set the icon name for the window
        (using gdk_window_set_icon_name()), the icon name will be set to
        @title as well. @title must be in UTF-8 encoding (as with all
        user-readable strings in GDK/GTK+). @title may not be %NULL.
        @param title: title of @window
        @type title: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_transient_for(self, parent=None):
        """        Indicates to the window manager that @window is a transient dialog
        associated with the application window @parent. This allows the
        window manager to do things like center @window on @parent and
        keep @window above @parent.
        
        See gtk_window_set_transient_for() if you’re using #GtkWindow or
        #GtkDialog.
        @param parent: another toplevel #GdkWindow
        @type parent: Window
        @returns: 
        @rtype: None
        """
        return object
    
    def set_type_hint(self, hint=None):
        """        The application can use this call to provide a hint to the window
        manager about the functionality of a window. The window manager
        can use this information when determining the decoration and behaviour
        of the window.
        
        The hint must be set before the window is mapped.
        @param hint: A hint of the function this window will have
        @type hint: WindowTypeHint
        @returns: 
        @rtype: None
        """
        return object
    
    def set_urgency_hint(self, urgent=None):
        """        Toggles whether a window needs the user's
        urgent attention.
        @param urgent: %TRUE if the window is urgent
        @type urgent: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def set_user_data(self, user_data=None):
        """        For most purposes this function is deprecated in favor of
        g_object_set_data(). However, for historical reasons GTK+ stores
        the #GtkWidget that owns a #GdkWindow as user data on the
        #GdkWindow. So, custom widget implementations should use
        this function for that. If GTK+ receives an event for a #GdkWindow,
        and the user data for the window is non-%NULL, GTK+ will assume the
        user data is a #GtkWidget, and forward the event to that widget.
        @param user_data: user data
        @type user_data: GObject.Object
        @returns: 
        @rtype: None
        """
        return object
    
    def shape_combine_region(self, shape_region=None, offset_x=None, offset_y=None):
        """        Makes pixels in @window outside @shape_region be transparent,
        so that the window may be nonrectangular.
        
        If @shape_region is %NULL, the shape will be unset, so the whole
        window will be opaque again. @offset_x and @offset_y are ignored
        if @shape_region is %NULL.
        
        On the X11 platform, this uses an X server extension which is
        widely available on most common platforms, but not available on
        very old X servers, and occasionally the implementation will be
        buggy. On servers without the shape extension, this function
        will do nothing.
        
        This function works on both toplevel and child windows.
        @param shape_region: region of window to be non-transparent
        @param offset_x: X position of @shape_region in @window coordinates
        @param offset_y: Y position of @shape_region in @window coordinates
        @type shape_region: cairo.Region
        @type offset_x: int
        @type offset_y: int
        @returns: 
        @rtype: None
        """
        return object
    
    def show(self):
        """        Like gdk_window_show_unraised(), but also raises the window to the
        top of the window stack (moves the window to the front of the
        Z-order).
        
        This function maps a window so it’s visible onscreen. Its opposite
        is gdk_window_hide().
        
        When implementing a #GtkWidget, you should call this function on the widget's
        #GdkWindow as part of the “map” method.
        @returns: 
        @rtype: None
        """
        return object
    
    def show_unraised(self):
        """        Shows a #GdkWindow onscreen, but does not modify its stacking
        order. In contrast, gdk_window_show() will raise the window
        to the top of the window stack.
        
        On the X11 platform, in Xlib terms, this function calls
        XMapWindow() (it also updates some internal GDK state, which means
        that you can’t really use XMapWindow() directly on a GDK window).
        @returns: 
        @rtype: None
        """
        return object
    
    def show_window_menu(self, event=None):
        """        Asks the windowing system to show the window menu. The window menu
        is the menu shown when right-clicking the titlebar on traditional
        windows managed by the window manager. This is useful for windows
        using client-side decorations, activating it with a right-click
        on the window decorations.
        @param event: a #GdkEvent to show the menu for
        @type event: Event
        @returns: %TRUE if the window menu was shown and %FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def stick(self):
        """        “Pins” a window such that it’s on all workspaces and does not scroll
        with viewports, for window managers that have scrollable viewports.
        (When using #GtkWindow, gtk_window_stick() may be more useful.)
        
        On the X11 platform, this function depends on window manager
        support, so may have no effect with many window managers. However,
        GDK will do the best it can to convince the window manager to stick
        the window. For window managers that don’t support this operation,
        there’s nothing you can do to force it to happen.
        @returns: 
        @rtype: None
        """
        return object
    
    def thaw_toplevel_updates_libgtk_only(self):
        """        Thaws a window frozen with
        gdk_window_freeze_toplevel_updates_libgtk_only().
        
        This function is not part of the GDK public API and is only
        for use by GTK+.
        @returns: 
        @rtype: None
        """
        return object
    
    def thaw_updates(self):
        """        Thaws a window frozen with gdk_window_freeze_updates().
        @returns: 
        @rtype: None
        """
        return object
    
    def unfullscreen(self):
        """        Moves the window out of fullscreen mode. If the window was not
        fullscreen, does nothing.
        
        On X11, asks the window manager to move @window out of the fullscreen
        state, if the window manager supports this operation. Not all
        window managers support this, and some deliberately ignore it or
        don’t have a concept of “fullscreen”; so you can’t rely on the
        unfullscreenification actually happening. But it will happen with
        most standard window managers, and GDK makes a best effort to get
        it to happen.
        @returns: 
        @rtype: None
        """
        return object
    
    def unmaximize(self):
        """        Unmaximizes the window. If the window wasn’t maximized, then this
        function does nothing.
        
        On X11, asks the window manager to unmaximize @window, if the
        window manager supports this operation. Not all window managers
        support this, and some deliberately ignore it or don’t have a
        concept of “maximized”; so you can’t rely on the unmaximization
        actually happening. But it will happen with most standard window
        managers, and GDK makes a best effort to get it to happen.
        
        On Windows, reliably unmaximizes the window.
        @returns: 
        @rtype: None
        """
        return object
    
    def unstick(self):
        """        Reverse operation for gdk_window_stick(); see gdk_window_stick(),
        and gtk_window_unstick().
        @returns: 
        @rtype: None
        """
        return object
    
    def withdraw(self):
        """        Withdraws a window (unmaps it and asks the window manager to forget about it).
        This function is not really useful as gdk_window_hide() automatically
        withdraws toplevel windows before hiding them.
        @returns: 
        @rtype: None
        """
        return object


class WindowAttr():
    """Attributes to use for a newly-created window."""

    @property
    def title(self):
        return object

    @property
    def event_mask(self):
        return object

    @property
    def x(self):
        return object

    @property
    def y(self):
        return object

    @property
    def width(self):
        return object

    @property
    def height(self):
        return object

    @property
    def wclass(self):
        return object

    @property
    def visual(self):
        return object

    @property
    def window_type(self):
        return object

    @property
    def cursor(self):
        return object

    @property
    def wmclass_name(self):
        return object

    @property
    def wmclass_class(self):
        return object

    @property
    def override_redirect(self):
        return object

    @property
    def type_hint(self):
        return object


class WindowClass():
    """"""

    @property
    def parent_class(self):
        return object

    @property
    def pick_embedded_child(self):
        return object

    @property
    def to_embedder(self):
        return object

    @property
    def from_embedder(self):
        return object

    @property
    def create_surface(self):
        return object

    @property
    def _gdk_reserved1(self):
        return object

    @property
    def _gdk_reserved2(self):
        return object

    @property
    def _gdk_reserved3(self):
        return object

    @property
    def _gdk_reserved4(self):
        return object

    @property
    def _gdk_reserved5(self):
        return object

    @property
    def _gdk_reserved6(self):
        return object

    @property
    def _gdk_reserved7(self):
        return object

    @property
    def _gdk_reserved8(self):
        return object


class WindowRedirect():
    """"""
